1//
2// cpp/gen/fasttest_gen.cpp
3// Generated by AMC
4//
5// Copyright (C) 2008-2013 AlgoEngineering LLC
6// Copyright (C) 2013-2019 NYSE | Intercontinental Exchange
7// Copyright (C) 2020-2023 Astra
8// Copyright (C) 2023 AlgoRND
9//
10// This source code constitutes confidential information and trade secrets
11// of AlgoRND. Unauthorized copying, distribution or sharing of this file,
12// via any medium, is strictly prohibited.
13//
14
15
16#include "include/algo.h" // hard-coded include
17#include "include/gen/fasttest_gen.h"
18#include "include/gen/fasttest_gen.inl.h"
19#include "include/gen/algo_gen.h"
20#include "include/gen/algo_gen.inl.h"
21//#pragma endinclude
22namespace fasttest { // gen:ns_print_proto
23 // func:fasttest.BVCopyNull.Value60.ReadStrptrMaybe
24 static bool Value60_ReadStrptrMaybe(fasttest::BVCopyNull &parent, algo::strptr in_str) __attribute__((nothrow));
25 // func:fasttest.BVCopyOpt.Value59.ReadStrptrMaybe
26 static bool Value59_ReadStrptrMaybe(fasttest::BVCopyOpt &parent, algo::strptr in_str) __attribute__((nothrow));
27 // func:fasttest.BVDfltNull.Value.ReadStrptrMaybe
28 static bool Value_ReadStrptrMaybe(fasttest::BVDfltNull &parent, algo::strptr in_str) __attribute__((nothrow));
29 // func:fasttest.BVDfltOpt.Value.ReadStrptrMaybe
30 static bool Value_ReadStrptrMaybe(fasttest::BVDfltOpt &parent, algo::strptr in_str) __attribute__((nothrow));
31 // func:fasttest.BVNoneOpt.Value.ReadStrptrMaybe
32 static bool Value_ReadStrptrMaybe(fasttest::BVNoneOpt &parent, algo::strptr in_str) __attribute__((nothrow));
33 // func:fasttest.SampleSet.prima.ReadStrptrMaybe
34 static bool prima_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) __attribute__((nothrow));
35 // func:fasttest.SampleSet.secunda.ReadStrptrMaybe
36 static bool secunda_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) __attribute__((nothrow));
37 // func:fasttest.SampleSet.tertia.ReadStrptrMaybe
38 static bool tertia_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) __attribute__((nothrow));
39 // func:fasttest.GroupSgmOpt.OptSgmGrp.ReadStrptrMaybe
40 static bool OptSgmGrp_ReadStrptrMaybe(fasttest::GroupSgmOpt &parent, algo::strptr in_str) __attribute__((nothrow));
41 // func:fasttest.GroupTrvOpt.OptTrvGrp.ReadStrptrMaybe
42 static bool OptTrvGrp_ReadStrptrMaybe(fasttest::GroupTrvOpt &parent, algo::strptr in_str) __attribute__((nothrow));
43 // func:fasttest.I32CopyNull.Value51.ReadStrptrMaybe
44 static bool Value51_ReadStrptrMaybe(fasttest::I32CopyNull &parent, algo::strptr in_str) __attribute__((nothrow));
45 // func:fasttest.I32CopyOpt.Value50.ReadStrptrMaybe
46 static bool Value50_ReadStrptrMaybe(fasttest::I32CopyOpt &parent, algo::strptr in_str) __attribute__((nothrow));
47 // func:fasttest.I32DeltaNull.Value68.ReadStrptrMaybe
48 static bool Value68_ReadStrptrMaybe(fasttest::I32DeltaNull &parent, algo::strptr in_str) __attribute__((nothrow));
49 // func:fasttest.I32DeltaOpt.Value67.ReadStrptrMaybe
50 static bool Value67_ReadStrptrMaybe(fasttest::I32DeltaOpt &parent, algo::strptr in_str) __attribute__((nothrow));
51 // func:fasttest.I32DfltNull.Value.ReadStrptrMaybe
52 static bool Value_ReadStrptrMaybe(fasttest::I32DfltNull &parent, algo::strptr in_str) __attribute__((nothrow));
53 // func:fasttest.I32DfltOpt.Value.ReadStrptrMaybe
54 static bool Value_ReadStrptrMaybe(fasttest::I32DfltOpt &parent, algo::strptr in_str) __attribute__((nothrow));
55 // func:fasttest.I32IncrNull.Value100.ReadStrptrMaybe
56 static bool Value100_ReadStrptrMaybe(fasttest::I32IncrNull &parent, algo::strptr in_str) __attribute__((nothrow));
57 // func:fasttest.I32IncrOpt.Value99.ReadStrptrMaybe
58 static bool Value99_ReadStrptrMaybe(fasttest::I32IncrOpt &parent, algo::strptr in_str) __attribute__((nothrow));
59 // func:fasttest.I32NoneOpt.Value.ReadStrptrMaybe
60 static bool Value_ReadStrptrMaybe(fasttest::I32NoneOpt &parent, algo::strptr in_str) __attribute__((nothrow));
61 // func:fasttest.SclCopyNull.Value63.ReadStrptrMaybe
62 static bool Value63_ReadStrptrMaybe(fasttest::SclCopyNull &parent, algo::strptr in_str) __attribute__((nothrow));
63 // func:fasttest.SclCopyOpt.Value62.ReadStrptrMaybe
64 static bool Value62_ReadStrptrMaybe(fasttest::SclCopyOpt &parent, algo::strptr in_str) __attribute__((nothrow));
65 // func:fasttest.SclDeltaNull.Value84.ReadStrptrMaybe
66 static bool Value84_ReadStrptrMaybe(fasttest::SclDeltaNull &parent, algo::strptr in_str) __attribute__((nothrow));
67 // func:fasttest.SclDeltaOpt.Value83.ReadStrptrMaybe
68 static bool Value83_ReadStrptrMaybe(fasttest::SclDeltaOpt &parent, algo::strptr in_str) __attribute__((nothrow));
69 // func:fasttest.SclDfltNull.Value.ReadStrptrMaybe
70 static bool Value_ReadStrptrMaybe(fasttest::SclDfltNull &parent, algo::strptr in_str) __attribute__((nothrow));
71 // func:fasttest.SclDfltOpt.Value.ReadStrptrMaybe
72 static bool Value_ReadStrptrMaybe(fasttest::SclDfltOpt &parent, algo::strptr in_str) __attribute__((nothrow));
73 // func:fasttest.SclNoneOpt.Value.ReadStrptrMaybe
74 static bool Value_ReadStrptrMaybe(fasttest::SclNoneOpt &parent, algo::strptr in_str) __attribute__((nothrow));
75 // func:fasttest.SeqTrvLenConstOpt.TrvSeqLenConstOpt.ReadStrptrMaybe
76 static bool TrvSeqLenConstOpt_ReadStrptrMaybe(fasttest::SeqTrvLenConstOpt &parent, algo::strptr in_str) __attribute__((nothrow));
77 // func:fasttest.StrCopyNull.Value57.ReadStrptrMaybe
78 static bool Value57_ReadStrptrMaybe(fasttest::StrCopyNull &parent, algo::strptr in_str) __attribute__((nothrow));
79 // func:fasttest.StrCopyOpt.Value56.ReadStrptrMaybe
80 static bool Value56_ReadStrptrMaybe(fasttest::StrCopyOpt &parent, algo::strptr in_str) __attribute__((nothrow));
81 // func:fasttest.StrDfltNull.Value.ReadStrptrMaybe
82 static bool Value_ReadStrptrMaybe(fasttest::StrDfltNull &parent, algo::strptr in_str) __attribute__((nothrow));
83 // func:fasttest.StrDfltOpt.Value.ReadStrptrMaybe
84 static bool Value_ReadStrptrMaybe(fasttest::StrDfltOpt &parent, algo::strptr in_str) __attribute__((nothrow));
85 // func:fasttest.StrNoneOpt.Value.ReadStrptrMaybe
86 static bool Value_ReadStrptrMaybe(fasttest::StrNoneOpt &parent, algo::strptr in_str) __attribute__((nothrow));
87 // func:fasttest.U32CopyNull.Value54.ReadStrptrMaybe
88 static bool Value54_ReadStrptrMaybe(fasttest::U32CopyNull &parent, algo::strptr in_str) __attribute__((nothrow));
89 // func:fasttest.U32CopyOpt.Value53.ReadStrptrMaybe
90 static bool Value53_ReadStrptrMaybe(fasttest::U32CopyOpt &parent, algo::strptr in_str) __attribute__((nothrow));
91 // func:fasttest.U32DeltaNull.Value72.ReadStrptrMaybe
92 static bool Value72_ReadStrptrMaybe(fasttest::U32DeltaNull &parent, algo::strptr in_str) __attribute__((nothrow));
93 // func:fasttest.U32DeltaOpt.Value71.ReadStrptrMaybe
94 static bool Value71_ReadStrptrMaybe(fasttest::U32DeltaOpt &parent, algo::strptr in_str) __attribute__((nothrow));
95 // func:fasttest.U32DfltNull.Value.ReadStrptrMaybe
96 static bool Value_ReadStrptrMaybe(fasttest::U32DfltNull &parent, algo::strptr in_str) __attribute__((nothrow));
97 // func:fasttest.U32DfltOpt.Value.ReadStrptrMaybe
98 static bool Value_ReadStrptrMaybe(fasttest::U32DfltOpt &parent, algo::strptr in_str) __attribute__((nothrow));
99 // func:fasttest.U32IncrNull.Value104.ReadStrptrMaybe
100 static bool Value104_ReadStrptrMaybe(fasttest::U32IncrNull &parent, algo::strptr in_str) __attribute__((nothrow));
101 // func:fasttest.U32IncrOpt.Value103.ReadStrptrMaybe
102 static bool Value103_ReadStrptrMaybe(fasttest::U32IncrOpt &parent, algo::strptr in_str) __attribute__((nothrow));
103 // func:fasttest.U32NoneOpt.Value.ReadStrptrMaybe
104 static bool Value_ReadStrptrMaybe(fasttest::U32NoneOpt &parent, algo::strptr in_str) __attribute__((nothrow));
105 // func:fasttest...SizeCheck
106 static void SizeCheck();
107} // gen:ns_print_proto
108
109// --- fasttest.BVConst.base.CopyOut
110// Copy fields out of row
111void fasttest::parent_CopyOut(fasttest::BVConst &row, fasttest::TemplateHeader &out) {
112 // length: field value is computed
113 // id: field value is computed
114 (void)row;//only to avoid -Wunused-parameter
115 (void)out;//only to avoid -Wunused-parameter
116}
117
118// --- fasttest.BVConst..ReadFieldMaybe
119bool fasttest::BVConst_ReadFieldMaybe(fasttest::BVConst& parent, algo::strptr field, algo::strptr strval) {
120 bool retval = true;
121 fasttest::FieldId field_id;
122 (void)value_SetStrptrMaybe(field_id,field);
123 switch(field_id) {
124 case fasttest_FieldId_base: {
125 retval = false;
126 break;
127 }
128 case fasttest_FieldId_length: {
129 retval = false;
130 break;
131 }
132 case fasttest_FieldId_id: {
133 retval = false;
134 break;
135 }
136 case fasttest_FieldId_Value: {
137 retval = true;
138 break;
139 }
140 default: break;
141 }
142 if (!retval) {
143 algo_lib::AppendErrtext("attr",field);
144 }
145 (void)parent;//only to avoid -Wunused-parameter
146 (void)strval;//only to avoid -Wunused-parameter
147 return retval;
148}
149
150// --- fasttest.BVConst..ReadStrptrMaybe
151// Read fields of fasttest::BVConst from an ascii string.
152// The format of the string is an ssim Tuple
153bool fasttest::BVConst_ReadStrptrMaybe(fasttest::BVConst &parent, algo::strptr in_str) {
154 bool retval = true;
155 retval = algo::StripTypeTag(in_str, "fasttest.BVConst");
156 ind_beg(algo::Attr_curs, attr, in_str) {
157 retval = retval && BVConst_ReadFieldMaybe(parent, attr.name, attr.value);
158 }ind_end;
159 return retval;
160}
161
162// --- fasttest.BVConst..Print
163// print string representation of ROW to string STR
164// cfmt:fasttest.BVConst.String printfmt:Tuple
165void fasttest::BVConst_Print(fasttest::BVConst& row, algo::cstring& str) {
166 algo::tempstr temp;
167 str << "fasttest.BVConst";
168
169 algo::strptr_Print(Value_Get(row), temp);
170 PrintAttrSpaceReset(str,"Value", temp);
171}
172
173// --- fasttest.BVConst..FastEncode
174void fasttest::BVConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVConst& parent) {
175 int index = ary_N(buf);
176 u64 pmap(0);
177 if (!tid_AssignedQ(state) || parent.id != state.tid) {
178 lib_fast::EncodeUnsigned(buf,parent.id,false);
179 lib_fast::SetPmapBit(pmap,0);
180 }
181 tid_SetAssigned(state);
182 state.tid = parent.id;
183 // Value byteVector constant mandatory
184 lib_fast::InsertPmap(buf,index,pmap);
185}
186
187// --- fasttest.BVConst..FastDecode
188bool fasttest::BVConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVConst& parent) {
189 bool ok = true;
190 // Value byteVector constant mandatory
191 if (ok) {
192 }
193 (void)from;//only to avoid -Wunused-parameter
194 (void)pmap;//only to avoid -Wunused-parameter
195 (void)state;//only to avoid -Wunused-parameter
196 (void)parent;//only to avoid -Wunused-parameter
197 return ok;
198}
199
200// --- fasttest.BVConst..FixEncode
201void fasttest::BVConst_FixEncode(cstring& buf, fasttest::BVConst& parent, char soh) {
202 buf << "1=" << Value_Get(parent) << soh;
203}
204
205// --- fasttest.BVConstOpt.base.CopyOut
206// Copy fields out of row
207void fasttest::parent_CopyOut(fasttest::BVConstOpt &row, fasttest::TemplateHeader &out) {
208 // length: field value is computed
209 // id: field value is computed
210 (void)row;//only to avoid -Wunused-parameter
211 (void)out;//only to avoid -Wunused-parameter
212}
213
214// --- fasttest.BVConstOpt.pmask_bitcurs.Next
215// proceed to next item
216void fasttest::BVConstOpt_pmask_bitcurs_Next(BVConstOpt_pmask_bitcurs &curs) {
217 ++curs.bit;
218 int index = curs.bit / 32;
219 int offset = curs.bit % 32;
220 for (; index < curs.n_elems; ++index, offset = 0) {
221 u64 rest = curs.elems[index] >> offset;
222 if (rest) {
223 offset += algo::u64_BitScanForward(rest);
224 break;
225 }
226 }
227 curs.bit = index * 32 + offset;
228}
229
230// --- fasttest.BVConstOpt..ReadFieldMaybe
231bool fasttest::BVConstOpt_ReadFieldMaybe(fasttest::BVConstOpt& parent, algo::strptr field, algo::strptr strval) {
232 bool retval = true;
233 fasttest::FieldId field_id;
234 (void)value_SetStrptrMaybe(field_id,field);
235 switch(field_id) {
236 case fasttest_FieldId_base: {
237 retval = false;
238 break;
239 }
240 case fasttest_FieldId_length: {
241 retval = false;
242 break;
243 }
244 case fasttest_FieldId_id: {
245 retval = false;
246 break;
247 }
248 case fasttest_FieldId_pmask: {
249 retval = false;
250 break;
251 }
252 case fasttest_FieldId_Value: {
253 retval = true;
254 if (retval) {
255 pmask_qSetBit(parent, 0);
256 }
257 break;
258 }
259 default: break;
260 }
261 if (!retval) {
262 algo_lib::AppendErrtext("attr",field);
263 }
264 (void)strval;//only to avoid -Wunused-parameter
265 return retval;
266}
267
268// --- fasttest.BVConstOpt..ReadStrptrMaybe
269// Read fields of fasttest::BVConstOpt from an ascii string.
270// The format of the string is an ssim Tuple
271bool fasttest::BVConstOpt_ReadStrptrMaybe(fasttest::BVConstOpt &parent, algo::strptr in_str) {
272 bool retval = true;
273 retval = algo::StripTypeTag(in_str, "fasttest.BVConstOpt");
274 ind_beg(algo::Attr_curs, attr, in_str) {
275 retval = retval && BVConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
276 }ind_end;
277 return retval;
278}
279
280// --- fasttest.BVConstOpt..Print
281// print string representation of ROW to string STR
282// cfmt:fasttest.BVConstOpt.String printfmt:Tuple
283void fasttest::BVConstOpt_Print(fasttest::BVConstOpt& row, algo::cstring& str) {
284 algo::tempstr temp;
285 str << "fasttest.BVConstOpt";
286
287 if (Value_PresentQ(row)) {
288 algo::strptr_Print(Value_Get(row), temp);
289 PrintAttrSpaceReset(str,"Value", temp);
290 }
291}
292
293// --- fasttest.BVConstOpt..FastEncode
294void fasttest::BVConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVConstOpt& parent) {
295 int index = ary_N(buf);
296 u64 pmap(0);
297 if (!tid_AssignedQ(state) || parent.id != state.tid) {
298 lib_fast::EncodeUnsigned(buf,parent.id,false);
299 lib_fast::SetPmapBit(pmap,0);
300 }
301 tid_SetAssigned(state);
302 state.tid = parent.id;
303 // Value byteVector constant optional
304 if (Value_PresentQ(parent)) {
305 lib_fast::SetPmapBit(pmap,1);
306 }
307 lib_fast::InsertPmap(buf,index,pmap);
308}
309
310// --- fasttest.BVConstOpt..FastDecode
311bool fasttest::BVConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVConstOpt& parent) {
312 bool ok = true;
313 // Value byteVector constant optional
314 if (ok) {
315 bool prs = lib_fast::GetPmapBit(pmap,1);
316 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
317 }
318 (void)from;//only to avoid -Wunused-parameter
319 (void)state;//only to avoid -Wunused-parameter
320 return ok;
321}
322
323// --- fasttest.BVConstOpt..FixEncode
324void fasttest::BVConstOpt_FixEncode(cstring& buf, fasttest::BVConstOpt& parent, char soh) {
325 if (Value_PresentQ(parent)) {
326 buf << "1=" << Value_Get(parent) << soh;
327 }
328}
329
330// --- fasttest.BVCopy.base.CopyOut
331// Copy fields out of row
332void fasttest::parent_CopyOut(fasttest::BVCopy &row, fasttest::TemplateHeader &out) {
333 // length: field value is computed
334 // id: field value is computed
335 (void)row;//only to avoid -Wunused-parameter
336 (void)out;//only to avoid -Wunused-parameter
337}
338
339// --- fasttest.BVCopy..ReadFieldMaybe
340bool fasttest::BVCopy_ReadFieldMaybe(fasttest::BVCopy& parent, algo::strptr field, algo::strptr strval) {
341 bool retval = true;
342 fasttest::FieldId field_id;
343 (void)value_SetStrptrMaybe(field_id,field);
344 switch(field_id) {
345 case fasttest_FieldId_base: {
346 retval = false;
347 break;
348 }
349 case fasttest_FieldId_length: {
350 retval = false;
351 break;
352 }
353 case fasttest_FieldId_id: {
354 retval = false;
355 break;
356 }
357 case fasttest_FieldId_Value58: {
358 retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value58, strval);
359 break;
360 }
361 default: break;
362 }
363 if (!retval) {
364 algo_lib::AppendErrtext("attr",field);
365 }
366 return retval;
367}
368
369// --- fasttest.BVCopy..ReadStrptrMaybe
370// Read fields of fasttest::BVCopy from an ascii string.
371// The format of the string is an ssim Tuple
372bool fasttest::BVCopy_ReadStrptrMaybe(fasttest::BVCopy &parent, algo::strptr in_str) {
373 bool retval = true;
374 retval = algo::StripTypeTag(in_str, "fasttest.BVCopy");
375 ind_beg(algo::Attr_curs, attr, in_str) {
376 retval = retval && BVCopy_ReadFieldMaybe(parent, attr.name, attr.value);
377 }ind_end;
378 return retval;
379}
380
381// --- fasttest.BVCopy..Print
382// print string representation of ROW to string STR
383// cfmt:fasttest.BVCopy.String printfmt:Tuple
384void fasttest::BVCopy_Print(fasttest::BVCopy& row, algo::cstring& str) {
385 algo::tempstr temp;
386 str << "fasttest.BVCopy";
387
388 algo::Smallstr30_Print(row.Value58, temp);
389 PrintAttrSpaceReset(str,"Value58", temp);
390}
391
392// --- fasttest.BVCopy..FastEncode
393void fasttest::BVCopy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVCopy& parent) {
394 int index = ary_N(buf);
395 u64 pmap(0);
396 if (!tid_AssignedQ(state) || parent.id != state.tid) {
397 lib_fast::EncodeUnsigned(buf,parent.id,false);
398 lib_fast::SetPmapBit(pmap,0);
399 }
400 tid_SetAssigned(state);
401 state.tid = parent.id;
402 // Value58 byteVector copy mandatory
403 if (Value58_AssignedQ(state) ? parent.Value58 != state.Value58 : parent.Value58 != "B58") {
404 lib_fast::EncodeByteVector(buf,parent.Value58,false);
405 lib_fast::SetPmapBit(pmap,1);
406 }
407 state.Value58 = parent.Value58;
408 Value58_SetAssigned(state);
409 lib_fast::InsertPmap(buf,index,pmap);
410}
411
412// --- fasttest.BVCopy..FastDecode
413bool fasttest::BVCopy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVCopy& parent) {
414 bool ok = true;
415 // Value58 byteVector copy mandatory
416 if (ok) {
417 bool prs = lib_fast::GetPmapBit(pmap,1);
418 if (prs) {
419 ok = lib_fast::DecodeByteVector(from,parent.Value58,false);
420 if (!ok) {
421 state.error << "fasttest.BVCopy.Value58: bad ByteVector" << eol;
422 }
423 } else if (Value58_AssignedQ(state)) {
424 parent.Value58 = state.Value58;
425 } else {
426 parent.Value58 = "B58";
427 }
428 Value58_SetAssigned(state);
429 state.Value58 = parent.Value58;
430 }
431 return ok;
432}
433
434// --- fasttest.BVCopy..FixEncode
435void fasttest::BVCopy_FixEncode(cstring& buf, fasttest::BVCopy& parent, char soh) {
436 buf << "1=" << parent.Value58 << soh;
437}
438
439// --- fasttest.BVCopyNull.base.CopyOut
440// Copy fields out of row
441void fasttest::parent_CopyOut(fasttest::BVCopyNull &row, fasttest::TemplateHeader &out) {
442 // length: field value is computed
443 // id: field value is computed
444 (void)row;//only to avoid -Wunused-parameter
445 (void)out;//only to avoid -Wunused-parameter
446}
447
448// --- fasttest.BVCopyNull.Value60.ReadStrptrMaybe
449inline static bool fasttest::Value60_ReadStrptrMaybe(fasttest::BVCopyNull &parent, algo::strptr in_str) {
450 bool retval = true;
451 algo::Smallstr30 Value60_tmp;
452 retval = algo::Smallstr30_ReadStrptrMaybe(Value60_tmp, in_str);
453 if (retval) {
454 Value60_Set(parent, Value60_tmp);
455 }
456 return retval;
457}
458
459// --- fasttest.BVCopyNull.pmask_bitcurs.Next
460// proceed to next item
461void fasttest::BVCopyNull_pmask_bitcurs_Next(BVCopyNull_pmask_bitcurs &curs) {
462 ++curs.bit;
463 int index = curs.bit / 32;
464 int offset = curs.bit % 32;
465 for (; index < curs.n_elems; ++index, offset = 0) {
466 u64 rest = curs.elems[index] >> offset;
467 if (rest) {
468 offset += algo::u64_BitScanForward(rest);
469 break;
470 }
471 }
472 curs.bit = index * 32 + offset;
473}
474
475// --- fasttest.BVCopyNull..ReadFieldMaybe
476bool fasttest::BVCopyNull_ReadFieldMaybe(fasttest::BVCopyNull& parent, algo::strptr field, algo::strptr strval) {
477 bool retval = true;
478 fasttest::FieldId field_id;
479 (void)value_SetStrptrMaybe(field_id,field);
480 switch(field_id) {
481 case fasttest_FieldId_base: {
482 retval = false;
483 break;
484 }
485 case fasttest_FieldId_length: {
486 retval = false;
487 break;
488 }
489 case fasttest_FieldId_id: {
490 retval = false;
491 break;
492 }
493 case fasttest_FieldId_pmask: {
494 retval = false;
495 break;
496 }
497 case fasttest_FieldId_Value60: {
498 retval = Value60_ReadStrptrMaybe(parent, strval);
499 if (retval) {
500 pmask_qSetBit(parent, 0);
501 }
502 break;
503 }
504 default: break;
505 }
506 if (!retval) {
507 algo_lib::AppendErrtext("attr",field);
508 }
509 return retval;
510}
511
512// --- fasttest.BVCopyNull..ReadStrptrMaybe
513// Read fields of fasttest::BVCopyNull from an ascii string.
514// The format of the string is an ssim Tuple
515bool fasttest::BVCopyNull_ReadStrptrMaybe(fasttest::BVCopyNull &parent, algo::strptr in_str) {
516 bool retval = true;
517 retval = algo::StripTypeTag(in_str, "fasttest.BVCopyNull");
518 ind_beg(algo::Attr_curs, attr, in_str) {
519 retval = retval && BVCopyNull_ReadFieldMaybe(parent, attr.name, attr.value);
520 }ind_end;
521 return retval;
522}
523
524// --- fasttest.BVCopyNull..Print
525// print string representation of ROW to string STR
526// cfmt:fasttest.BVCopyNull.String printfmt:Tuple
527void fasttest::BVCopyNull_Print(fasttest::BVCopyNull& row, algo::cstring& str) {
528 algo::tempstr temp;
529 str << "fasttest.BVCopyNull";
530
531 if (Value60_PresentQ(row)) {
532 algo::Smallstr30_Print(row.Value60, temp);
533 PrintAttrSpaceReset(str,"Value60", temp);
534 }
535}
536
537// --- fasttest.BVCopyNull..FastEncode
538void fasttest::BVCopyNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVCopyNull& parent) {
539 int index = ary_N(buf);
540 u64 pmap(0);
541 if (!tid_AssignedQ(state) || parent.id != state.tid) {
542 lib_fast::EncodeUnsigned(buf,parent.id,false);
543 lib_fast::SetPmapBit(pmap,0);
544 }
545 tid_SetAssigned(state);
546 state.tid = parent.id;
547 // Value60 byteVector copy optional
548 if (Value60_PresentQ(parent)) {
549 if (!Value60_AssignedQ(state) || !Value60_PresentQ(state) || parent.Value60 != state.Value60 ) {
550 lib_fast::EncodeByteVector(buf,parent.Value60,true);
551 lib_fast::SetPmapBit(pmap,1);
552 }
553 } else {
554 if (Value60_AssignedQ(state)) {
555 lib_fast::EncodeNull(buf);
556 lib_fast::SetPmapBit(pmap,1);
557 }
558 }
559 state.Value60 = parent.Value60;
560 present_qSetBitVal(state,Value60_Present_GetBit(state),Value60_PresentQ(parent));
561 Value60_SetAssigned(state);
562 lib_fast::InsertPmap(buf,index,pmap);
563}
564
565// --- fasttest.BVCopyNull..FastDecode
566bool fasttest::BVCopyNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVCopyNull& parent) {
567 bool ok = true;
568 // Value60 byteVector copy optional
569 if (ok) {
570 bool prs = lib_fast::GetPmapBit(pmap,1);
571 if (prs) {
572 prs = !lib_fast::DecodeNull(from);
573 if (prs) {
574 ok = lib_fast::DecodeByteVector(from,parent.Value60,true);
575 if (!ok) {
576 state.error << "fasttest.BVCopyNull.Value60: bad ByteVector" << eol;
577 }
578 }
579 } else if (Value60_AssignedQ(state)) {
580 parent.Value60 = state.Value60;
581 prs = Value60_PresentQ(state);
582 } else {
583 prs = false;
584 }
585 pmask_qSetBitVal(parent,Value60_Present_GetBit(parent),prs);
586 Value60_SetAssigned(state);
587 present_qSetBitVal(state,Value60_Present_GetBit(state),prs);
588 state.Value60 = parent.Value60;
589 }
590 return ok;
591}
592
593// --- fasttest.BVCopyNull..FixEncode
594void fasttest::BVCopyNull_FixEncode(cstring& buf, fasttest::BVCopyNull& parent, char soh) {
595 if (Value60_PresentQ(parent)) {
596 buf << "1=" << parent.Value60 << soh;
597 }
598}
599
600// --- fasttest.BVCopyOpt.base.CopyOut
601// Copy fields out of row
602void fasttest::parent_CopyOut(fasttest::BVCopyOpt &row, fasttest::TemplateHeader &out) {
603 // length: field value is computed
604 // id: field value is computed
605 (void)row;//only to avoid -Wunused-parameter
606 (void)out;//only to avoid -Wunused-parameter
607}
608
609// --- fasttest.BVCopyOpt.Value59.ReadStrptrMaybe
610inline static bool fasttest::Value59_ReadStrptrMaybe(fasttest::BVCopyOpt &parent, algo::strptr in_str) {
611 bool retval = true;
612 algo::Smallstr30 Value59_tmp;
613 retval = algo::Smallstr30_ReadStrptrMaybe(Value59_tmp, in_str);
614 if (retval) {
615 Value59_Set(parent, Value59_tmp);
616 }
617 return retval;
618}
619
620// --- fasttest.BVCopyOpt.pmask_bitcurs.Next
621// proceed to next item
622void fasttest::BVCopyOpt_pmask_bitcurs_Next(BVCopyOpt_pmask_bitcurs &curs) {
623 ++curs.bit;
624 int index = curs.bit / 32;
625 int offset = curs.bit % 32;
626 for (; index < curs.n_elems; ++index, offset = 0) {
627 u64 rest = curs.elems[index] >> offset;
628 if (rest) {
629 offset += algo::u64_BitScanForward(rest);
630 break;
631 }
632 }
633 curs.bit = index * 32 + offset;
634}
635
636// --- fasttest.BVCopyOpt..ReadFieldMaybe
637bool fasttest::BVCopyOpt_ReadFieldMaybe(fasttest::BVCopyOpt& parent, algo::strptr field, algo::strptr strval) {
638 bool retval = true;
639 fasttest::FieldId field_id;
640 (void)value_SetStrptrMaybe(field_id,field);
641 switch(field_id) {
642 case fasttest_FieldId_base: {
643 retval = false;
644 break;
645 }
646 case fasttest_FieldId_length: {
647 retval = false;
648 break;
649 }
650 case fasttest_FieldId_id: {
651 retval = false;
652 break;
653 }
654 case fasttest_FieldId_pmask: {
655 retval = false;
656 break;
657 }
658 case fasttest_FieldId_Value59: {
659 retval = Value59_ReadStrptrMaybe(parent, strval);
660 if (retval) {
661 pmask_qSetBit(parent, 0);
662 }
663 break;
664 }
665 default: break;
666 }
667 if (!retval) {
668 algo_lib::AppendErrtext("attr",field);
669 }
670 return retval;
671}
672
673// --- fasttest.BVCopyOpt..ReadStrptrMaybe
674// Read fields of fasttest::BVCopyOpt from an ascii string.
675// The format of the string is an ssim Tuple
676bool fasttest::BVCopyOpt_ReadStrptrMaybe(fasttest::BVCopyOpt &parent, algo::strptr in_str) {
677 bool retval = true;
678 retval = algo::StripTypeTag(in_str, "fasttest.BVCopyOpt");
679 ind_beg(algo::Attr_curs, attr, in_str) {
680 retval = retval && BVCopyOpt_ReadFieldMaybe(parent, attr.name, attr.value);
681 }ind_end;
682 return retval;
683}
684
685// --- fasttest.BVCopyOpt..Print
686// print string representation of ROW to string STR
687// cfmt:fasttest.BVCopyOpt.String printfmt:Tuple
688void fasttest::BVCopyOpt_Print(fasttest::BVCopyOpt& row, algo::cstring& str) {
689 algo::tempstr temp;
690 str << "fasttest.BVCopyOpt";
691
692 if (Value59_PresentQ(row)) {
693 algo::Smallstr30_Print(row.Value59, temp);
694 PrintAttrSpaceReset(str,"Value59", temp);
695 }
696}
697
698// --- fasttest.BVCopyOpt..FastEncode
699void fasttest::BVCopyOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVCopyOpt& parent) {
700 int index = ary_N(buf);
701 u64 pmap(0);
702 if (!tid_AssignedQ(state) || parent.id != state.tid) {
703 lib_fast::EncodeUnsigned(buf,parent.id,false);
704 lib_fast::SetPmapBit(pmap,0);
705 }
706 tid_SetAssigned(state);
707 state.tid = parent.id;
708 // Value59 byteVector copy optional
709 if (Value59_PresentQ(parent)) {
710 if (Value59_AssignedQ(state) ? !Value59_PresentQ(state) || parent.Value59 != state.Value59 : parent.Value59 != "B59") {
711 lib_fast::EncodeByteVector(buf,parent.Value59,true);
712 lib_fast::SetPmapBit(pmap,1);
713 }
714 } else {
715 if (Value59_AssignedQ(state) && Value59_PresentQ(state)) {
716 lib_fast::EncodeNull(buf);
717 lib_fast::SetPmapBit(pmap,1);
718 }
719 }
720 state.Value59 = parent.Value59;
721 present_qSetBitVal(state,Value59_Present_GetBit(state),Value59_PresentQ(parent));
722 Value59_SetAssigned(state);
723 lib_fast::InsertPmap(buf,index,pmap);
724}
725
726// --- fasttest.BVCopyOpt..FastDecode
727bool fasttest::BVCopyOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVCopyOpt& parent) {
728 bool ok = true;
729 // Value59 byteVector copy optional
730 if (ok) {
731 bool prs = lib_fast::GetPmapBit(pmap,1);
732 if (prs) {
733 prs = !lib_fast::DecodeNull(from);
734 if (prs) {
735 ok = lib_fast::DecodeByteVector(from,parent.Value59,true);
736 if (!ok) {
737 state.error << "fasttest.BVCopyOpt.Value59: bad ByteVector" << eol;
738 }
739 }
740 } else if (Value59_AssignedQ(state)) {
741 parent.Value59 = state.Value59;
742 prs = Value59_PresentQ(state);
743 } else {
744 parent.Value59 = "B59";
745 prs = true;
746 }
747 pmask_qSetBitVal(parent,Value59_Present_GetBit(parent),prs);
748 Value59_SetAssigned(state);
749 present_qSetBitVal(state,Value59_Present_GetBit(state),prs);
750 state.Value59 = parent.Value59;
751 }
752 return ok;
753}
754
755// --- fasttest.BVCopyOpt..FixEncode
756void fasttest::BVCopyOpt_FixEncode(cstring& buf, fasttest::BVCopyOpt& parent, char soh) {
757 if (Value59_PresentQ(parent)) {
758 buf << "1=" << parent.Value59 << soh;
759 }
760}
761
762// --- fasttest.BVDflt.base.CopyOut
763// Copy fields out of row
764void fasttest::parent_CopyOut(fasttest::BVDflt &row, fasttest::TemplateHeader &out) {
765 // length: field value is computed
766 // id: field value is computed
767 (void)row;//only to avoid -Wunused-parameter
768 (void)out;//only to avoid -Wunused-parameter
769}
770
771// --- fasttest.BVDflt..ReadFieldMaybe
772bool fasttest::BVDflt_ReadFieldMaybe(fasttest::BVDflt& parent, algo::strptr field, algo::strptr strval) {
773 bool retval = true;
774 fasttest::FieldId field_id;
775 (void)value_SetStrptrMaybe(field_id,field);
776 switch(field_id) {
777 case fasttest_FieldId_base: {
778 retval = false;
779 break;
780 }
781 case fasttest_FieldId_length: {
782 retval = false;
783 break;
784 }
785 case fasttest_FieldId_id: {
786 retval = false;
787 break;
788 }
789 case fasttest_FieldId_Value: {
790 retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value, strval);
791 break;
792 }
793 default: break;
794 }
795 if (!retval) {
796 algo_lib::AppendErrtext("attr",field);
797 }
798 return retval;
799}
800
801// --- fasttest.BVDflt..ReadStrptrMaybe
802// Read fields of fasttest::BVDflt from an ascii string.
803// The format of the string is an ssim Tuple
804bool fasttest::BVDflt_ReadStrptrMaybe(fasttest::BVDflt &parent, algo::strptr in_str) {
805 bool retval = true;
806 retval = algo::StripTypeTag(in_str, "fasttest.BVDflt");
807 ind_beg(algo::Attr_curs, attr, in_str) {
808 retval = retval && BVDflt_ReadFieldMaybe(parent, attr.name, attr.value);
809 }ind_end;
810 return retval;
811}
812
813// --- fasttest.BVDflt..Print
814// print string representation of ROW to string STR
815// cfmt:fasttest.BVDflt.String printfmt:Tuple
816void fasttest::BVDflt_Print(fasttest::BVDflt& row, algo::cstring& str) {
817 algo::tempstr temp;
818 str << "fasttest.BVDflt";
819
820 algo::Smallstr30_Print(row.Value, temp);
821 PrintAttrSpaceReset(str,"Value", temp);
822}
823
824// --- fasttest.BVDflt..FastEncode
825void fasttest::BVDflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVDflt& parent) {
826 int index = ary_N(buf);
827 u64 pmap(0);
828 if (!tid_AssignedQ(state) || parent.id != state.tid) {
829 lib_fast::EncodeUnsigned(buf,parent.id,false);
830 lib_fast::SetPmapBit(pmap,0);
831 }
832 tid_SetAssigned(state);
833 state.tid = parent.id;
834 // Value byteVector default mandatory
835 if (parent.Value != "B42") {
836 lib_fast::EncodeByteVector(buf,parent.Value,false);
837 lib_fast::SetPmapBit(pmap,1);
838 }
839 lib_fast::InsertPmap(buf,index,pmap);
840}
841
842// --- fasttest.BVDflt..FastDecode
843bool fasttest::BVDflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVDflt& parent) {
844 bool ok = true;
845 // Value byteVector default mandatory
846 if (ok) {
847 bool prs = lib_fast::GetPmapBit(pmap,1);
848 if (prs) {
849 ok = lib_fast::DecodeByteVector(from,parent.Value,false);
850 if (!ok) {
851 state.error << "fasttest.BVDflt.Value: bad ByteVector" << eol;
852 }
853 } else {
854 parent.Value = "B42";
855 }
856 }
857 return ok;
858}
859
860// --- fasttest.BVDflt..FixEncode
861void fasttest::BVDflt_FixEncode(cstring& buf, fasttest::BVDflt& parent, char soh) {
862 buf << "1=" << parent.Value << soh;
863}
864
865// --- fasttest.BVDfltNull.base.CopyOut
866// Copy fields out of row
867void fasttest::parent_CopyOut(fasttest::BVDfltNull &row, fasttest::TemplateHeader &out) {
868 // length: field value is computed
869 // id: field value is computed
870 (void)row;//only to avoid -Wunused-parameter
871 (void)out;//only to avoid -Wunused-parameter
872}
873
874// --- fasttest.BVDfltNull.Value.ReadStrptrMaybe
875inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::BVDfltNull &parent, algo::strptr in_str) {
876 bool retval = true;
877 algo::Smallstr30 Value_tmp;
878 retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
879 if (retval) {
880 Value_Set(parent, Value_tmp);
881 }
882 return retval;
883}
884
885// --- fasttest.BVDfltNull.pmask_bitcurs.Next
886// proceed to next item
887void fasttest::BVDfltNull_pmask_bitcurs_Next(BVDfltNull_pmask_bitcurs &curs) {
888 ++curs.bit;
889 int index = curs.bit / 32;
890 int offset = curs.bit % 32;
891 for (; index < curs.n_elems; ++index, offset = 0) {
892 u64 rest = curs.elems[index] >> offset;
893 if (rest) {
894 offset += algo::u64_BitScanForward(rest);
895 break;
896 }
897 }
898 curs.bit = index * 32 + offset;
899}
900
901// --- fasttest.BVDfltNull..ReadFieldMaybe
902bool fasttest::BVDfltNull_ReadFieldMaybe(fasttest::BVDfltNull& parent, algo::strptr field, algo::strptr strval) {
903 bool retval = true;
904 fasttest::FieldId field_id;
905 (void)value_SetStrptrMaybe(field_id,field);
906 switch(field_id) {
907 case fasttest_FieldId_base: {
908 retval = false;
909 break;
910 }
911 case fasttest_FieldId_length: {
912 retval = false;
913 break;
914 }
915 case fasttest_FieldId_id: {
916 retval = false;
917 break;
918 }
919 case fasttest_FieldId_pmask: {
920 retval = false;
921 break;
922 }
923 case fasttest_FieldId_Value: {
924 retval = Value_ReadStrptrMaybe(parent, strval);
925 if (retval) {
926 pmask_qSetBit(parent, 0);
927 }
928 break;
929 }
930 default: break;
931 }
932 if (!retval) {
933 algo_lib::AppendErrtext("attr",field);
934 }
935 return retval;
936}
937
938// --- fasttest.BVDfltNull..ReadStrptrMaybe
939// Read fields of fasttest::BVDfltNull from an ascii string.
940// The format of the string is an ssim Tuple
941bool fasttest::BVDfltNull_ReadStrptrMaybe(fasttest::BVDfltNull &parent, algo::strptr in_str) {
942 bool retval = true;
943 retval = algo::StripTypeTag(in_str, "fasttest.BVDfltNull");
944 ind_beg(algo::Attr_curs, attr, in_str) {
945 retval = retval && BVDfltNull_ReadFieldMaybe(parent, attr.name, attr.value);
946 }ind_end;
947 return retval;
948}
949
950// --- fasttest.BVDfltNull..Print
951// print string representation of ROW to string STR
952// cfmt:fasttest.BVDfltNull.String printfmt:Tuple
953void fasttest::BVDfltNull_Print(fasttest::BVDfltNull& row, algo::cstring& str) {
954 algo::tempstr temp;
955 str << "fasttest.BVDfltNull";
956
957 if (Value_PresentQ(row)) {
958 algo::Smallstr30_Print(row.Value, temp);
959 PrintAttrSpaceReset(str,"Value", temp);
960 }
961}
962
963// --- fasttest.BVDfltNull..FastEncode
964void fasttest::BVDfltNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVDfltNull& parent) {
965 int index = ary_N(buf);
966 u64 pmap(0);
967 if (!tid_AssignedQ(state) || parent.id != state.tid) {
968 lib_fast::EncodeUnsigned(buf,parent.id,false);
969 lib_fast::SetPmapBit(pmap,0);
970 }
971 tid_SetAssigned(state);
972 state.tid = parent.id;
973 // Value byteVector default optional
974 if (Value_PresentQ(parent)) {
975 lib_fast::EncodeByteVector(buf,parent.Value,true);
976 lib_fast::SetPmapBit(pmap,1);
977 }
978 lib_fast::InsertPmap(buf,index,pmap);
979}
980
981// --- fasttest.BVDfltNull..FastDecode
982bool fasttest::BVDfltNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVDfltNull& parent) {
983 bool ok = true;
984 // Value byteVector default optional
985 if (ok) {
986 bool prs = lib_fast::GetPmapBit(pmap,1);
987 if (prs) {
988 prs = !lib_fast::DecodeNull(from);
989 if (prs) {
990 ok = lib_fast::DecodeByteVector(from,parent.Value,true);
991 if (!ok) {
992 state.error << "fasttest.BVDfltNull.Value: bad ByteVector" << eol;
993 }
994 }
995 } else {
996 }
997 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
998 }
999 return ok;
1000}
1001
1002// --- fasttest.BVDfltNull..FixEncode
1003void fasttest::BVDfltNull_FixEncode(cstring& buf, fasttest::BVDfltNull& parent, char soh) {
1004 if (Value_PresentQ(parent)) {
1005 buf << "1=" << parent.Value << soh;
1006 }
1007}
1008
1009// --- fasttest.BVDfltOpt.base.CopyOut
1010// Copy fields out of row
1011void fasttest::parent_CopyOut(fasttest::BVDfltOpt &row, fasttest::TemplateHeader &out) {
1012 // length: field value is computed
1013 // id: field value is computed
1014 (void)row;//only to avoid -Wunused-parameter
1015 (void)out;//only to avoid -Wunused-parameter
1016}
1017
1018// --- fasttest.BVDfltOpt.Value.ReadStrptrMaybe
1019inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::BVDfltOpt &parent, algo::strptr in_str) {
1020 bool retval = true;
1021 algo::Smallstr30 Value_tmp;
1022 retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
1023 if (retval) {
1024 Value_Set(parent, Value_tmp);
1025 }
1026 return retval;
1027}
1028
1029// --- fasttest.BVDfltOpt.pmask_bitcurs.Next
1030// proceed to next item
1031void fasttest::BVDfltOpt_pmask_bitcurs_Next(BVDfltOpt_pmask_bitcurs &curs) {
1032 ++curs.bit;
1033 int index = curs.bit / 32;
1034 int offset = curs.bit % 32;
1035 for (; index < curs.n_elems; ++index, offset = 0) {
1036 u64 rest = curs.elems[index] >> offset;
1037 if (rest) {
1038 offset += algo::u64_BitScanForward(rest);
1039 break;
1040 }
1041 }
1042 curs.bit = index * 32 + offset;
1043}
1044
1045// --- fasttest.BVDfltOpt..ReadFieldMaybe
1046bool fasttest::BVDfltOpt_ReadFieldMaybe(fasttest::BVDfltOpt& parent, algo::strptr field, algo::strptr strval) {
1047 bool retval = true;
1048 fasttest::FieldId field_id;
1049 (void)value_SetStrptrMaybe(field_id,field);
1050 switch(field_id) {
1051 case fasttest_FieldId_base: {
1052 retval = false;
1053 break;
1054 }
1055 case fasttest_FieldId_length: {
1056 retval = false;
1057 break;
1058 }
1059 case fasttest_FieldId_id: {
1060 retval = false;
1061 break;
1062 }
1063 case fasttest_FieldId_pmask: {
1064 retval = false;
1065 break;
1066 }
1067 case fasttest_FieldId_Value: {
1068 retval = Value_ReadStrptrMaybe(parent, strval);
1069 if (retval) {
1070 pmask_qSetBit(parent, 0);
1071 }
1072 break;
1073 }
1074 default: break;
1075 }
1076 if (!retval) {
1077 algo_lib::AppendErrtext("attr",field);
1078 }
1079 return retval;
1080}
1081
1082// --- fasttest.BVDfltOpt..ReadStrptrMaybe
1083// Read fields of fasttest::BVDfltOpt from an ascii string.
1084// The format of the string is an ssim Tuple
1085bool fasttest::BVDfltOpt_ReadStrptrMaybe(fasttest::BVDfltOpt &parent, algo::strptr in_str) {
1086 bool retval = true;
1087 retval = algo::StripTypeTag(in_str, "fasttest.BVDfltOpt");
1088 ind_beg(algo::Attr_curs, attr, in_str) {
1089 retval = retval && BVDfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
1090 }ind_end;
1091 return retval;
1092}
1093
1094// --- fasttest.BVDfltOpt..Print
1095// print string representation of ROW to string STR
1096// cfmt:fasttest.BVDfltOpt.String printfmt:Tuple
1097void fasttest::BVDfltOpt_Print(fasttest::BVDfltOpt& row, algo::cstring& str) {
1098 algo::tempstr temp;
1099 str << "fasttest.BVDfltOpt";
1100
1101 if (Value_PresentQ(row)) {
1102 algo::Smallstr30_Print(row.Value, temp);
1103 PrintAttrSpaceReset(str,"Value", temp);
1104 }
1105}
1106
1107// --- fasttest.BVDfltOpt..FastEncode
1108void fasttest::BVDfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVDfltOpt& parent) {
1109 int index = ary_N(buf);
1110 u64 pmap(0);
1111 if (!tid_AssignedQ(state) || parent.id != state.tid) {
1112 lib_fast::EncodeUnsigned(buf,parent.id,false);
1113 lib_fast::SetPmapBit(pmap,0);
1114 }
1115 tid_SetAssigned(state);
1116 state.tid = parent.id;
1117 // Value byteVector default optional
1118 if (Value_PresentQ(parent)) {
1119 if (parent.Value != "B43") {
1120 lib_fast::EncodeByteVector(buf,parent.Value,true);
1121 lib_fast::SetPmapBit(pmap,1);
1122 }
1123 } else {
1124 lib_fast::EncodeNull(buf);
1125 lib_fast::SetPmapBit(pmap,1);
1126 }
1127 lib_fast::InsertPmap(buf,index,pmap);
1128}
1129
1130// --- fasttest.BVDfltOpt..FastDecode
1131bool fasttest::BVDfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVDfltOpt& parent) {
1132 bool ok = true;
1133 // Value byteVector default optional
1134 if (ok) {
1135 bool prs = lib_fast::GetPmapBit(pmap,1);
1136 if (prs) {
1137 prs = !lib_fast::DecodeNull(from);
1138 if (prs) {
1139 ok = lib_fast::DecodeByteVector(from,parent.Value,true);
1140 if (!ok) {
1141 state.error << "fasttest.BVDfltOpt.Value: bad ByteVector" << eol;
1142 }
1143 }
1144 } else {
1145 parent.Value = "B43";
1146 prs = true;
1147 }
1148 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
1149 }
1150 return ok;
1151}
1152
1153// --- fasttest.BVDfltOpt..FixEncode
1154void fasttest::BVDfltOpt_FixEncode(cstring& buf, fasttest::BVDfltOpt& parent, char soh) {
1155 if (Value_PresentQ(parent)) {
1156 buf << "1=" << parent.Value << soh;
1157 }
1158}
1159
1160// --- fasttest.BVNone.base.CopyOut
1161// Copy fields out of row
1162void fasttest::parent_CopyOut(fasttest::BVNone &row, fasttest::TemplateHeader &out) {
1163 // length: field value is computed
1164 // id: field value is computed
1165 (void)row;//only to avoid -Wunused-parameter
1166 (void)out;//only to avoid -Wunused-parameter
1167}
1168
1169// --- fasttest.BVNone..ReadFieldMaybe
1170bool fasttest::BVNone_ReadFieldMaybe(fasttest::BVNone& parent, algo::strptr field, algo::strptr strval) {
1171 bool retval = true;
1172 fasttest::FieldId field_id;
1173 (void)value_SetStrptrMaybe(field_id,field);
1174 switch(field_id) {
1175 case fasttest_FieldId_base: {
1176 retval = false;
1177 break;
1178 }
1179 case fasttest_FieldId_length: {
1180 retval = false;
1181 break;
1182 }
1183 case fasttest_FieldId_id: {
1184 retval = false;
1185 break;
1186 }
1187 case fasttest_FieldId_Value: {
1188 retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value, strval);
1189 break;
1190 }
1191 default: break;
1192 }
1193 if (!retval) {
1194 algo_lib::AppendErrtext("attr",field);
1195 }
1196 return retval;
1197}
1198
1199// --- fasttest.BVNone..ReadStrptrMaybe
1200// Read fields of fasttest::BVNone from an ascii string.
1201// The format of the string is an ssim Tuple
1202bool fasttest::BVNone_ReadStrptrMaybe(fasttest::BVNone &parent, algo::strptr in_str) {
1203 bool retval = true;
1204 retval = algo::StripTypeTag(in_str, "fasttest.BVNone");
1205 ind_beg(algo::Attr_curs, attr, in_str) {
1206 retval = retval && BVNone_ReadFieldMaybe(parent, attr.name, attr.value);
1207 }ind_end;
1208 return retval;
1209}
1210
1211// --- fasttest.BVNone..Print
1212// print string representation of ROW to string STR
1213// cfmt:fasttest.BVNone.String printfmt:Tuple
1214void fasttest::BVNone_Print(fasttest::BVNone& row, algo::cstring& str) {
1215 algo::tempstr temp;
1216 str << "fasttest.BVNone";
1217
1218 algo::Smallstr30_Print(row.Value, temp);
1219 PrintAttrSpaceReset(str,"Value", temp);
1220}
1221
1222// --- fasttest.BVNone..FastEncode
1223void fasttest::BVNone_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVNone& parent) {
1224 int index = ary_N(buf);
1225 u64 pmap(0);
1226 if (!tid_AssignedQ(state) || parent.id != state.tid) {
1227 lib_fast::EncodeUnsigned(buf,parent.id,false);
1228 lib_fast::SetPmapBit(pmap,0);
1229 }
1230 tid_SetAssigned(state);
1231 state.tid = parent.id;
1232 // Value byteVector none mandatory
1233 lib_fast::EncodeByteVector(buf,parent.Value,false);
1234 lib_fast::InsertPmap(buf,index,pmap);
1235}
1236
1237// --- fasttest.BVNone..FastDecode
1238bool fasttest::BVNone_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVNone& parent) {
1239 bool ok = true;
1240 // Value byteVector none mandatory
1241 if (ok) {
1242 ok = lib_fast::DecodeByteVector(from,parent.Value,false);
1243 if (!ok) {
1244 state.error << "fasttest.BVNone.Value: bad ByteVector" << eol;
1245 }
1246 }
1247 (void)pmap;//only to avoid -Wunused-parameter
1248 return ok;
1249}
1250
1251// --- fasttest.BVNone..FixEncode
1252void fasttest::BVNone_FixEncode(cstring& buf, fasttest::BVNone& parent, char soh) {
1253 buf << "1=" << parent.Value << soh;
1254}
1255
1256// --- fasttest.BVNoneOpt.base.CopyOut
1257// Copy fields out of row
1258void fasttest::parent_CopyOut(fasttest::BVNoneOpt &row, fasttest::TemplateHeader &out) {
1259 // length: field value is computed
1260 // id: field value is computed
1261 (void)row;//only to avoid -Wunused-parameter
1262 (void)out;//only to avoid -Wunused-parameter
1263}
1264
1265// --- fasttest.BVNoneOpt.Value.ReadStrptrMaybe
1266inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::BVNoneOpt &parent, algo::strptr in_str) {
1267 bool retval = true;
1268 algo::Smallstr30 Value_tmp;
1269 retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
1270 if (retval) {
1271 Value_Set(parent, Value_tmp);
1272 }
1273 return retval;
1274}
1275
1276// --- fasttest.BVNoneOpt.pmask_bitcurs.Next
1277// proceed to next item
1278void fasttest::BVNoneOpt_pmask_bitcurs_Next(BVNoneOpt_pmask_bitcurs &curs) {
1279 ++curs.bit;
1280 int index = curs.bit / 32;
1281 int offset = curs.bit % 32;
1282 for (; index < curs.n_elems; ++index, offset = 0) {
1283 u64 rest = curs.elems[index] >> offset;
1284 if (rest) {
1285 offset += algo::u64_BitScanForward(rest);
1286 break;
1287 }
1288 }
1289 curs.bit = index * 32 + offset;
1290}
1291
1292// --- fasttest.BVNoneOpt..ReadFieldMaybe
1293bool fasttest::BVNoneOpt_ReadFieldMaybe(fasttest::BVNoneOpt& parent, algo::strptr field, algo::strptr strval) {
1294 bool retval = true;
1295 fasttest::FieldId field_id;
1296 (void)value_SetStrptrMaybe(field_id,field);
1297 switch(field_id) {
1298 case fasttest_FieldId_base: {
1299 retval = false;
1300 break;
1301 }
1302 case fasttest_FieldId_length: {
1303 retval = false;
1304 break;
1305 }
1306 case fasttest_FieldId_id: {
1307 retval = false;
1308 break;
1309 }
1310 case fasttest_FieldId_pmask: {
1311 retval = false;
1312 break;
1313 }
1314 case fasttest_FieldId_Value: {
1315 retval = Value_ReadStrptrMaybe(parent, strval);
1316 if (retval) {
1317 pmask_qSetBit(parent, 0);
1318 }
1319 break;
1320 }
1321 default: break;
1322 }
1323 if (!retval) {
1324 algo_lib::AppendErrtext("attr",field);
1325 }
1326 return retval;
1327}
1328
1329// --- fasttest.BVNoneOpt..ReadStrptrMaybe
1330// Read fields of fasttest::BVNoneOpt from an ascii string.
1331// The format of the string is an ssim Tuple
1332bool fasttest::BVNoneOpt_ReadStrptrMaybe(fasttest::BVNoneOpt &parent, algo::strptr in_str) {
1333 bool retval = true;
1334 retval = algo::StripTypeTag(in_str, "fasttest.BVNoneOpt");
1335 ind_beg(algo::Attr_curs, attr, in_str) {
1336 retval = retval && BVNoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
1337 }ind_end;
1338 return retval;
1339}
1340
1341// --- fasttest.BVNoneOpt..Print
1342// print string representation of ROW to string STR
1343// cfmt:fasttest.BVNoneOpt.String printfmt:Tuple
1344void fasttest::BVNoneOpt_Print(fasttest::BVNoneOpt& row, algo::cstring& str) {
1345 algo::tempstr temp;
1346 str << "fasttest.BVNoneOpt";
1347
1348 if (Value_PresentQ(row)) {
1349 algo::Smallstr30_Print(row.Value, temp);
1350 PrintAttrSpaceReset(str,"Value", temp);
1351 }
1352}
1353
1354// --- fasttest.BVNoneOpt..FastEncode
1355void fasttest::BVNoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::BVNoneOpt& parent) {
1356 int index = ary_N(buf);
1357 u64 pmap(0);
1358 if (!tid_AssignedQ(state) || parent.id != state.tid) {
1359 lib_fast::EncodeUnsigned(buf,parent.id,false);
1360 lib_fast::SetPmapBit(pmap,0);
1361 }
1362 tid_SetAssigned(state);
1363 state.tid = parent.id;
1364 // Value byteVector none optional
1365 if (Value_PresentQ(parent)) {
1366 lib_fast::EncodeByteVector(buf,parent.Value,true);
1367 } else {
1368 lib_fast::EncodeNull(buf);
1369 }
1370 lib_fast::InsertPmap(buf,index,pmap);
1371}
1372
1373// --- fasttest.BVNoneOpt..FastDecode
1374bool fasttest::BVNoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::BVNoneOpt& parent) {
1375 bool ok = true;
1376 // Value byteVector none optional
1377 if (ok) {
1378 bool prs = !lib_fast::DecodeNull(from);
1379 if (prs) {
1380 ok = lib_fast::DecodeByteVector(from,parent.Value,true);
1381 if (!ok) {
1382 state.error << "fasttest.BVNoneOpt.Value: bad ByteVector" << eol;
1383 }
1384 }
1385 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
1386 }
1387 (void)pmap;//only to avoid -Wunused-parameter
1388 return ok;
1389}
1390
1391// --- fasttest.BVNoneOpt..FixEncode
1392void fasttest::BVNoneOpt_FixEncode(cstring& buf, fasttest::BVNoneOpt& parent, char soh) {
1393 if (Value_PresentQ(parent)) {
1394 buf << "1=" << parent.Value << soh;
1395 }
1396}
1397
1398// --- fasttest.SampleEnum.value.ToCstr
1399// Convert numeric value of field to one of predefined string constants.
1400// If string is found, return a static C string. Otherwise, return NULL.
1401const char* fasttest::value_ToCstr(const fasttest::SampleEnum& parent) {
1402 const char *ret = NULL;
1403 switch(value_GetEnum(parent)) {
1404 case fasttest_SampleEnum_first : ret = "first"; break;
1405 case fasttest_SampleEnum_second : ret = "second"; break;
1406 case fasttest_SampleEnum_third : ret = "third"; break;
1407 }
1408 return ret;
1409}
1410
1411// --- fasttest.SampleEnum.value.Print
1412// Convert value to a string. First, attempt conversion to a known string.
1413// If no string matches, print value as a numeric value.
1414void fasttest::value_Print(const fasttest::SampleEnum& parent, algo::cstring &lhs) {
1415 const char *strval = value_ToCstr(parent);
1416 if (strval) {
1417 lhs << strval;
1418 } else {
1419 lhs << parent.value;
1420 }
1421}
1422
1423// --- fasttest.SampleEnum.value.SetStrptrMaybe
1424// Convert string to field.
1425// If the string is invalid, do not modify field and return false.
1426// In case of success, return true
1427bool fasttest::value_SetStrptrMaybe(fasttest::SampleEnum& parent, algo::strptr rhs) {
1428 bool ret = false;
1429 switch (elems_N(rhs)) {
1430 case 5: {
1431 switch (u64(algo::ReadLE32(rhs.elems))|(u64(rhs[4])<<32)) {
1432 case LE_STR5('f','i','r','s','t'): {
1433 value_SetEnum(parent,fasttest_SampleEnum_first); ret = true; break;
1434 }
1435 case LE_STR5('t','h','i','r','d'): {
1436 value_SetEnum(parent,fasttest_SampleEnum_third); ret = true; break;
1437 }
1438 }
1439 break;
1440 }
1441 case 6: {
1442 switch (u64(algo::ReadLE32(rhs.elems))|(u64(algo::ReadLE16(rhs.elems+4))<<32)) {
1443 case LE_STR6('s','e','c','o','n','d'): {
1444 value_SetEnum(parent,fasttest_SampleEnum_second); ret = true; break;
1445 }
1446 }
1447 break;
1448 }
1449 }
1450 return ret;
1451}
1452
1453// --- fasttest.SampleEnum.value.SetStrptr
1454// Convert string to field.
1455// If the string is invalid, set numeric value to DFLT
1456void fasttest::value_SetStrptr(fasttest::SampleEnum& parent, algo::strptr rhs, fasttest_SampleEnumEnum dflt) {
1457 if (!value_SetStrptrMaybe(parent,rhs)) value_SetEnum(parent,dflt);
1458}
1459
1460// --- fasttest.SampleEnum.value.ReadStrptrMaybe
1461// Convert string to field. Return success value
1462bool fasttest::value_ReadStrptrMaybe(fasttest::SampleEnum& parent, algo::strptr rhs) {
1463 bool retval = false;
1464 retval = value_SetStrptrMaybe(parent,rhs); // try symbol conversion
1465 if (!retval) { // didn't work? try reading as underlying type
1466 retval = u32_ReadStrptrMaybe(parent.value,rhs);
1467 }
1468 return retval;
1469}
1470
1471// --- fasttest.SampleEnum..ReadStrptrMaybe
1472// Read fields of fasttest::SampleEnum from an ascii string.
1473// The format of the string is the format of the fasttest::SampleEnum's only field
1474bool fasttest::SampleEnum_ReadStrptrMaybe(fasttest::SampleEnum &parent, algo::strptr in_str) {
1475 bool retval = true;
1476 retval = retval && value_ReadStrptrMaybe(parent, in_str);
1477 return retval;
1478}
1479
1480// --- fasttest.SampleEnum..Print
1481// print string representation of ROW to string STR
1482// cfmt:fasttest.SampleEnum.String printfmt:Raw
1483void fasttest::SampleEnum_Print(fasttest::SampleEnum row, algo::cstring& str) {
1484 fasttest::value_Print(row, str);
1485}
1486
1487// --- fasttest.SampleSet.prima.ReadStrptrMaybe
1488inline static bool fasttest::prima_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) {
1489 bool retval = true;
1490 bool prima_tmp;
1491 retval = bool_ReadStrptrMaybe(prima_tmp, in_str);
1492 if (retval) {
1493 prima_Set(parent, prima_tmp);
1494 }
1495 return retval;
1496}
1497
1498// --- fasttest.SampleSet.secunda.ReadStrptrMaybe
1499inline static bool fasttest::secunda_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) {
1500 bool retval = true;
1501 bool secunda_tmp;
1502 retval = bool_ReadStrptrMaybe(secunda_tmp, in_str);
1503 if (retval) {
1504 secunda_Set(parent, secunda_tmp);
1505 }
1506 return retval;
1507}
1508
1509// --- fasttest.SampleSet.tertia.ReadStrptrMaybe
1510inline static bool fasttest::tertia_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) {
1511 bool retval = true;
1512 bool tertia_tmp;
1513 retval = bool_ReadStrptrMaybe(tertia_tmp, in_str);
1514 if (retval) {
1515 tertia_Set(parent, tertia_tmp);
1516 }
1517 return retval;
1518}
1519
1520// --- fasttest.SampleSet..ReadFieldMaybe
1521bool fasttest::SampleSet_ReadFieldMaybe(fasttest::SampleSet& parent, algo::strptr field, algo::strptr strval) {
1522 bool retval = true;
1523 fasttest::FieldId field_id;
1524 (void)value_SetStrptrMaybe(field_id,field);
1525 switch(field_id) {
1526 case fasttest_FieldId_value: {
1527 retval = u32_ReadStrptrMaybe(parent.value, strval);
1528 break;
1529 }
1530 case fasttest_FieldId_prima: {
1531 retval = prima_ReadStrptrMaybe(parent, strval);
1532 break;
1533 }
1534 case fasttest_FieldId_secunda: {
1535 retval = secunda_ReadStrptrMaybe(parent, strval);
1536 break;
1537 }
1538 case fasttest_FieldId_tertia: {
1539 retval = tertia_ReadStrptrMaybe(parent, strval);
1540 break;
1541 }
1542 default: break;
1543 }
1544 if (!retval) {
1545 algo_lib::AppendErrtext("attr",field);
1546 }
1547 return retval;
1548}
1549
1550// --- fasttest.SampleSet..ReadStrptrMaybe
1551// Read fields of fasttest::SampleSet from an ascii string.
1552bool fasttest::SampleSet_ReadStrptrMaybe(fasttest::SampleSet &parent, algo::strptr in_str) {
1553 bool retval = true;
1554 // Clear affected bits first)
1555 prima_Set(parent, false);
1556 secunda_Set(parent, false);
1557 tertia_Set(parent, false);
1558 // Read ' '-separated list of bools
1559 while (ch_N(in_str)) {
1560 strptr field_name;
1561 algo::NextSep(in_str,' ',field_name);
1562 field_name = algo::Trimmed(field_name);
1563 if (ch_N(field_name)) {
1564 fasttest::FieldId field_id;
1565 bool ok = fasttest::value_SetStrptrMaybe(field_id,field_name);
1566 if (ok) {
1567 switch (field_id) {
1568 case fasttest_FieldId_prima: {
1569 prima_Set(parent, true);
1570 } break;
1571 case fasttest_FieldId_secunda: {
1572 secunda_Set(parent, true);
1573 } break;
1574 case fasttest_FieldId_tertia: {
1575 tertia_Set(parent, true);
1576 } break;
1577 default: ok = false; break;
1578 }
1579 }
1580 if (!ok) {
1581 algo_lib::AppendErrtext("bitfld",field_name);
1582 retval = false;
1583 }
1584 }
1585 }
1586 return retval;
1587}
1588
1589// --- fasttest.SampleSet..Print
1590// print string representation of ROW to string STR
1591// cfmt:fasttest.SampleSet.String printfmt:Bitset
1592void fasttest::SampleSet_Print(fasttest::SampleSet row, algo::cstring& str) {
1593 algo::ListSep ls(" ");
1594 if (prima_Get(row)) {
1595 str << ls << "prima";
1596 }
1597 if (secunda_Get(row)) {
1598 str << ls << "secunda";
1599 }
1600 if (tertia_Get(row)) {
1601 str << ls << "tertia";
1602 }
1603}
1604
1605// --- fasttest.FastState.assigned_bitcurs.Next
1606// proceed to next item
1607void fasttest::FastState_assigned_bitcurs_Next(FastState_assigned_bitcurs &curs) {
1608 ++curs.bit;
1609 int index = curs.bit / 64;
1610 int offset = curs.bit % 64;
1611 for (; index < curs.n_elems; ++index, offset = 0) {
1612 u64 rest = curs.elems[index] >> offset;
1613 if (rest) {
1614 offset += algo::u64_BitScanForward(rest);
1615 break;
1616 }
1617 }
1618 curs.bit = index * 64 + offset;
1619}
1620
1621// --- fasttest.FastState.present_bitcurs.Next
1622// proceed to next item
1623void fasttest::FastState_present_bitcurs_Next(FastState_present_bitcurs &curs) {
1624 ++curs.bit;
1625 int index = curs.bit / 32;
1626 int offset = curs.bit % 32;
1627 for (; index < curs.n_elems; ++index, offset = 0) {
1628 u64 rest = curs.elems[index] >> offset;
1629 if (rest) {
1630 offset += algo::u64_BitScanForward(rest);
1631 break;
1632 }
1633 }
1634 curs.bit = index * 32 + offset;
1635}
1636
1637// --- fasttest.FastState..Init
1638// Set all fields to initial values.
1639void fasttest::FastState_Init(fasttest::FastState& parent) {
1640 parent.assigned = u64(0);
1641 parent.present = u32(0);
1642 parent.tid = u32(0);
1643 parent.Value49 = i32(0);
1644 parent.Value50 = i32(0);
1645 parent.Value51 = i32(0);
1646 parent.Value52 = u32(0);
1647 parent.Value53 = u32(0);
1648 parent.Value54 = u32(0);
1649 parent.Value65 = i32(0);
1650 parent.Value66 = i32(0);
1651 parent.Value67 = i32(0);
1652 parent.Value68 = i32(0);
1653 parent.Value69 = u32(0);
1654 parent.Value70 = u32(0);
1655 parent.Value71 = u32(0);
1656 parent.Value72 = u32(0);
1657 parent.Value97 = i32(0);
1658 parent.Value98 = i32(0);
1659 parent.Value99 = i32(0);
1660 parent.Value100 = i32(0);
1661 parent.Value101 = u32(0);
1662 parent.Value102 = u32(0);
1663 parent.Value103 = u32(0);
1664 parent.Value104 = u32(0);
1665}
1666
1667// --- fasttest.FieldId.value.ToCstr
1668// Convert numeric value of field to one of predefined string constants.
1669// If string is found, return a static C string. Otherwise, return NULL.
1670const char* fasttest::value_ToCstr(const fasttest::FieldId& parent) {
1671 const char *ret = NULL;
1672 switch(value_GetEnum(parent)) {
1673 case fasttest_FieldId_base : ret = "base"; break;
1674 case fasttest_FieldId_length : ret = "length"; break;
1675 case fasttest_FieldId_id : ret = "id"; break;
1676 case fasttest_FieldId_Value : ret = "Value"; break;
1677 case fasttest_FieldId_pmask : ret = "pmask"; break;
1678 case fasttest_FieldId_Value58 : ret = "Value58"; break;
1679 case fasttest_FieldId_Value60 : ret = "Value60"; break;
1680 case fasttest_FieldId_Value59 : ret = "Value59"; break;
1681 case fasttest_FieldId_Value1 : ret = "Value1"; break;
1682 case fasttest_FieldId_OptSgmGrp : ret = "OptSgmGrp"; break;
1683 case fasttest_FieldId_TrvGrp : ret = "TrvGrp"; break;
1684 case fasttest_FieldId_OptTrvGrp : ret = "OptTrvGrp"; break;
1685 case fasttest_FieldId_Value49 : ret = "Value49"; break;
1686 case fasttest_FieldId_Value51 : ret = "Value51"; break;
1687 case fasttest_FieldId_Value50 : ret = "Value50"; break;
1688 case fasttest_FieldId_Value65 : ret = "Value65"; break;
1689 case fasttest_FieldId_Value66 : ret = "Value66"; break;
1690 case fasttest_FieldId_Value68 : ret = "Value68"; break;
1691 case fasttest_FieldId_Value67 : ret = "Value67"; break;
1692 case fasttest_FieldId_Value97 : ret = "Value97"; break;
1693 case fasttest_FieldId_Value98 : ret = "Value98"; break;
1694 case fasttest_FieldId_Value100 : ret = "Value100"; break;
1695 case fasttest_FieldId_Value99 : ret = "Value99"; break;
1696 case fasttest_FieldId_Value2 : ret = "Value2"; break;
1697 case fasttest_FieldId_Value3 : ret = "Value3"; break;
1698 case fasttest_FieldId_Value4 : ret = "Value4"; break;
1699 case fasttest_FieldId_Value5 : ret = "Value5"; break;
1700 case fasttest_FieldId_Value6 : ret = "Value6"; break;
1701 case fasttest_FieldId_Value7 : ret = "Value7"; break;
1702 case fasttest_FieldId_Value8 : ret = "Value8"; break;
1703 case fasttest_FieldId_Value9 : ret = "Value9"; break;
1704 case fasttest_FieldId_Value10 : ret = "Value10"; break;
1705 case fasttest_FieldId_Value11 : ret = "Value11"; break;
1706 case fasttest_FieldId_Value12 : ret = "Value12"; break;
1707 case fasttest_FieldId_Value13 : ret = "Value13"; break;
1708 case fasttest_FieldId_Value14 : ret = "Value14"; break;
1709 case fasttest_FieldId_Value15 : ret = "Value15"; break;
1710 case fasttest_FieldId_Value16 : ret = "Value16"; break;
1711 case fasttest_FieldId_Value17 : ret = "Value17"; break;
1712 case fasttest_FieldId_Value18 : ret = "Value18"; break;
1713 case fasttest_FieldId_Value19 : ret = "Value19"; break;
1714 case fasttest_FieldId_Value20 : ret = "Value20"; break;
1715 case fasttest_FieldId_Value21 : ret = "Value21"; break;
1716 case fasttest_FieldId_Value22 : ret = "Value22"; break;
1717 case fasttest_FieldId_Value23 : ret = "Value23"; break;
1718 case fasttest_FieldId_Value24 : ret = "Value24"; break;
1719 case fasttest_FieldId_Value25 : ret = "Value25"; break;
1720 case fasttest_FieldId_Value26 : ret = "Value26"; break;
1721 case fasttest_FieldId_Value27 : ret = "Value27"; break;
1722 case fasttest_FieldId_Value28 : ret = "Value28"; break;
1723 case fasttest_FieldId_Value29 : ret = "Value29"; break;
1724 case fasttest_FieldId_Value30 : ret = "Value30"; break;
1725 case fasttest_FieldId_Value31 : ret = "Value31"; break;
1726 case fasttest_FieldId_Value32 : ret = "Value32"; break;
1727 case fasttest_FieldId_Value33 : ret = "Value33"; break;
1728 case fasttest_FieldId_Value34 : ret = "Value34"; break;
1729 case fasttest_FieldId_Value35 : ret = "Value35"; break;
1730 case fasttest_FieldId_Value36 : ret = "Value36"; break;
1731 case fasttest_FieldId_Value37 : ret = "Value37"; break;
1732 case fasttest_FieldId_Value38 : ret = "Value38"; break;
1733 case fasttest_FieldId_Value39 : ret = "Value39"; break;
1734 case fasttest_FieldId_Value40 : ret = "Value40"; break;
1735 case fasttest_FieldId_Value41 : ret = "Value41"; break;
1736 case fasttest_FieldId_Value42 : ret = "Value42"; break;
1737 case fasttest_FieldId_Value43 : ret = "Value43"; break;
1738 case fasttest_FieldId_Value44 : ret = "Value44"; break;
1739 case fasttest_FieldId_Value45 : ret = "Value45"; break;
1740 case fasttest_FieldId_Value46 : ret = "Value46"; break;
1741 case fasttest_FieldId_Value47 : ret = "Value47"; break;
1742 case fasttest_FieldId_Value48 : ret = "Value48"; break;
1743 case fasttest_FieldId_Value52 : ret = "Value52"; break;
1744 case fasttest_FieldId_Value53 : ret = "Value53"; break;
1745 case fasttest_FieldId_Value54 : ret = "Value54"; break;
1746 case fasttest_FieldId_Value55 : ret = "Value55"; break;
1747 case fasttest_FieldId_Value56 : ret = "Value56"; break;
1748 case fasttest_FieldId_Value57 : ret = "Value57"; break;
1749 case fasttest_FieldId_Value61 : ret = "Value61"; break;
1750 case fasttest_FieldId_Value62 : ret = "Value62"; break;
1751 case fasttest_FieldId_Value63 : ret = "Value63"; break;
1752 case fasttest_FieldId_value : ret = "value"; break;
1753 case fasttest_FieldId_Value147 : ret = "Value147"; break;
1754 case fasttest_FieldId_prima : ret = "prima"; break;
1755 case fasttest_FieldId_secunda : ret = "secunda"; break;
1756 case fasttest_FieldId_tertia : ret = "tertia"; break;
1757 case fasttest_FieldId_Value150 : ret = "Value150"; break;
1758 case fasttest_FieldId_Value81 : ret = "Value81"; break;
1759 case fasttest_FieldId_Value82 : ret = "Value82"; break;
1760 case fasttest_FieldId_Value84 : ret = "Value84"; break;
1761 case fasttest_FieldId_Value83 : ret = "Value83"; break;
1762 case fasttest_FieldId_SecondSeq : ret = "SecondSeq"; break;
1763 case fasttest_FieldId_FirstSeq : ret = "FirstSeq"; break;
1764 case fasttest_FieldId_OptSgmSeq : ret = "OptSgmSeq"; break;
1765 case fasttest_FieldId_TrvSeq : ret = "TrvSeq"; break;
1766 case fasttest_FieldId_TrvSeqLenConst: ret = "TrvSeqLenConst"; break;
1767 case fasttest_FieldId_TrvSeqLenConstOpt: ret = "TrvSeqLenConstOpt"; break;
1768 case fasttest_FieldId_TrvSeqLenDflt: ret = "TrvSeqLenDflt"; break;
1769 case fasttest_FieldId_TrvSeqDfltOpt: ret = "TrvSeqDfltOpt"; break;
1770 case fasttest_FieldId_TrvSeqLenNone: ret = "TrvSeqLenNone"; break;
1771 case fasttest_FieldId_TrvSeqLenNoneOpt: ret = "TrvSeqLenNoneOpt"; break;
1772 case fasttest_FieldId_OptTrvSeq : ret = "OptTrvSeq"; break;
1773 case fasttest_FieldId_Value69 : ret = "Value69"; break;
1774 case fasttest_FieldId_Value70 : ret = "Value70"; break;
1775 case fasttest_FieldId_Value72 : ret = "Value72"; break;
1776 case fasttest_FieldId_Value71 : ret = "Value71"; break;
1777 case fasttest_FieldId_Value101 : ret = "Value101"; break;
1778 case fasttest_FieldId_Value102 : ret = "Value102"; break;
1779 case fasttest_FieldId_Value104 : ret = "Value104"; break;
1780 case fasttest_FieldId_Value103 : ret = "Value103"; break;
1781 }
1782 return ret;
1783}
1784
1785// --- fasttest.FieldId.value.Print
1786// Convert value to a string. First, attempt conversion to a known string.
1787// If no string matches, print value as a numeric value.
1788void fasttest::value_Print(const fasttest::FieldId& parent, algo::cstring &lhs) {
1789 const char *strval = value_ToCstr(parent);
1790 if (strval) {
1791 lhs << strval;
1792 } else {
1793 lhs << parent.value;
1794 }
1795}
1796
1797// --- fasttest.FieldId.value.SetStrptrMaybe
1798// Convert string to field.
1799// If the string is invalid, do not modify field and return false.
1800// In case of success, return true
1801bool fasttest::value_SetStrptrMaybe(fasttest::FieldId& parent, algo::strptr rhs) {
1802 bool ret = false;
1803 switch (elems_N(rhs)) {
1804 case 2: {
1805 switch (u64(algo::ReadLE16(rhs.elems))) {
1806 case LE_STR2('i','d'): {
1807 value_SetEnum(parent,fasttest_FieldId_id); ret = true; break;
1808 }
1809 }
1810 break;
1811 }
1812 case 4: {
1813 switch (u64(algo::ReadLE32(rhs.elems))) {
1814 case LE_STR4('b','a','s','e'): {
1815 value_SetEnum(parent,fasttest_FieldId_base); ret = true; break;
1816 }
1817 }
1818 break;
1819 }
1820 case 5: {
1821 switch (u64(algo::ReadLE32(rhs.elems))|(u64(rhs[4])<<32)) {
1822 case LE_STR5('V','a','l','u','e'): {
1823 value_SetEnum(parent,fasttest_FieldId_Value); ret = true; break;
1824 }
1825 case LE_STR5('p','m','a','s','k'): {
1826 value_SetEnum(parent,fasttest_FieldId_pmask); ret = true; break;
1827 }
1828 case LE_STR5('p','r','i','m','a'): {
1829 value_SetEnum(parent,fasttest_FieldId_prima); ret = true; break;
1830 }
1831 case LE_STR5('v','a','l','u','e'): {
1832 value_SetEnum(parent,fasttest_FieldId_value); ret = true; break;
1833 }
1834 }
1835 break;
1836 }
1837 case 6: {
1838 switch (u64(algo::ReadLE32(rhs.elems))|(u64(algo::ReadLE16(rhs.elems+4))<<32)) {
1839 case LE_STR6('T','r','v','G','r','p'): {
1840 value_SetEnum(parent,fasttest_FieldId_TrvGrp); ret = true; break;
1841 }
1842 case LE_STR6('T','r','v','S','e','q'): {
1843 value_SetEnum(parent,fasttest_FieldId_TrvSeq); ret = true; break;
1844 }
1845 case LE_STR6('V','a','l','u','e','1'): {
1846 value_SetEnum(parent,fasttest_FieldId_Value1); ret = true; break;
1847 }
1848 case LE_STR6('V','a','l','u','e','2'): {
1849 value_SetEnum(parent,fasttest_FieldId_Value2); ret = true; break;
1850 }
1851 case LE_STR6('V','a','l','u','e','3'): {
1852 value_SetEnum(parent,fasttest_FieldId_Value3); ret = true; break;
1853 }
1854 case LE_STR6('V','a','l','u','e','4'): {
1855 value_SetEnum(parent,fasttest_FieldId_Value4); ret = true; break;
1856 }
1857 case LE_STR6('V','a','l','u','e','5'): {
1858 value_SetEnum(parent,fasttest_FieldId_Value5); ret = true; break;
1859 }
1860 case LE_STR6('V','a','l','u','e','6'): {
1861 value_SetEnum(parent,fasttest_FieldId_Value6); ret = true; break;
1862 }
1863 case LE_STR6('V','a','l','u','e','7'): {
1864 value_SetEnum(parent,fasttest_FieldId_Value7); ret = true; break;
1865 }
1866 case LE_STR6('V','a','l','u','e','8'): {
1867 value_SetEnum(parent,fasttest_FieldId_Value8); ret = true; break;
1868 }
1869 case LE_STR6('V','a','l','u','e','9'): {
1870 value_SetEnum(parent,fasttest_FieldId_Value9); ret = true; break;
1871 }
1872 case LE_STR6('l','e','n','g','t','h'): {
1873 value_SetEnum(parent,fasttest_FieldId_length); ret = true; break;
1874 }
1875 case LE_STR6('t','e','r','t','i','a'): {
1876 value_SetEnum(parent,fasttest_FieldId_tertia); ret = true; break;
1877 }
1878 }
1879 break;
1880 }
1881 case 7: {
1882 switch (u64(algo::ReadLE32(rhs.elems))|(u64(algo::ReadLE16(rhs.elems+4))<<32)|(u64(rhs[6])<<48)) {
1883 case LE_STR7('V','a','l','u','e','1','0'): {
1884 value_SetEnum(parent,fasttest_FieldId_Value10); ret = true; break;
1885 }
1886 case LE_STR7('V','a','l','u','e','1','1'): {
1887 value_SetEnum(parent,fasttest_FieldId_Value11); ret = true; break;
1888 }
1889 case LE_STR7('V','a','l','u','e','1','2'): {
1890 value_SetEnum(parent,fasttest_FieldId_Value12); ret = true; break;
1891 }
1892 case LE_STR7('V','a','l','u','e','1','3'): {
1893 value_SetEnum(parent,fasttest_FieldId_Value13); ret = true; break;
1894 }
1895 case LE_STR7('V','a','l','u','e','1','4'): {
1896 value_SetEnum(parent,fasttest_FieldId_Value14); ret = true; break;
1897 }
1898 case LE_STR7('V','a','l','u','e','1','5'): {
1899 value_SetEnum(parent,fasttest_FieldId_Value15); ret = true; break;
1900 }
1901 case LE_STR7('V','a','l','u','e','1','6'): {
1902 value_SetEnum(parent,fasttest_FieldId_Value16); ret = true; break;
1903 }
1904 case LE_STR7('V','a','l','u','e','1','7'): {
1905 value_SetEnum(parent,fasttest_FieldId_Value17); ret = true; break;
1906 }
1907 case LE_STR7('V','a','l','u','e','1','8'): {
1908 value_SetEnum(parent,fasttest_FieldId_Value18); ret = true; break;
1909 }
1910 case LE_STR7('V','a','l','u','e','1','9'): {
1911 value_SetEnum(parent,fasttest_FieldId_Value19); ret = true; break;
1912 }
1913 case LE_STR7('V','a','l','u','e','2','0'): {
1914 value_SetEnum(parent,fasttest_FieldId_Value20); ret = true; break;
1915 }
1916 case LE_STR7('V','a','l','u','e','2','1'): {
1917 value_SetEnum(parent,fasttest_FieldId_Value21); ret = true; break;
1918 }
1919 case LE_STR7('V','a','l','u','e','2','2'): {
1920 value_SetEnum(parent,fasttest_FieldId_Value22); ret = true; break;
1921 }
1922 case LE_STR7('V','a','l','u','e','2','3'): {
1923 value_SetEnum(parent,fasttest_FieldId_Value23); ret = true; break;
1924 }
1925 case LE_STR7('V','a','l','u','e','2','4'): {
1926 value_SetEnum(parent,fasttest_FieldId_Value24); ret = true; break;
1927 }
1928 case LE_STR7('V','a','l','u','e','2','5'): {
1929 value_SetEnum(parent,fasttest_FieldId_Value25); ret = true; break;
1930 }
1931 case LE_STR7('V','a','l','u','e','2','6'): {
1932 value_SetEnum(parent,fasttest_FieldId_Value26); ret = true; break;
1933 }
1934 case LE_STR7('V','a','l','u','e','2','7'): {
1935 value_SetEnum(parent,fasttest_FieldId_Value27); ret = true; break;
1936 }
1937 case LE_STR7('V','a','l','u','e','2','8'): {
1938 value_SetEnum(parent,fasttest_FieldId_Value28); ret = true; break;
1939 }
1940 case LE_STR7('V','a','l','u','e','2','9'): {
1941 value_SetEnum(parent,fasttest_FieldId_Value29); ret = true; break;
1942 }
1943 case LE_STR7('V','a','l','u','e','3','0'): {
1944 value_SetEnum(parent,fasttest_FieldId_Value30); ret = true; break;
1945 }
1946 case LE_STR7('V','a','l','u','e','3','1'): {
1947 value_SetEnum(parent,fasttest_FieldId_Value31); ret = true; break;
1948 }
1949 case LE_STR7('V','a','l','u','e','3','2'): {
1950 value_SetEnum(parent,fasttest_FieldId_Value32); ret = true; break;
1951 }
1952 case LE_STR7('V','a','l','u','e','3','3'): {
1953 value_SetEnum(parent,fasttest_FieldId_Value33); ret = true; break;
1954 }
1955 case LE_STR7('V','a','l','u','e','3','4'): {
1956 value_SetEnum(parent,fasttest_FieldId_Value34); ret = true; break;
1957 }
1958 case LE_STR7('V','a','l','u','e','3','5'): {
1959 value_SetEnum(parent,fasttest_FieldId_Value35); ret = true; break;
1960 }
1961 case LE_STR7('V','a','l','u','e','3','6'): {
1962 value_SetEnum(parent,fasttest_FieldId_Value36); ret = true; break;
1963 }
1964 case LE_STR7('V','a','l','u','e','3','7'): {
1965 value_SetEnum(parent,fasttest_FieldId_Value37); ret = true; break;
1966 }
1967 case LE_STR7('V','a','l','u','e','3','8'): {
1968 value_SetEnum(parent,fasttest_FieldId_Value38); ret = true; break;
1969 }
1970 case LE_STR7('V','a','l','u','e','3','9'): {
1971 value_SetEnum(parent,fasttest_FieldId_Value39); ret = true; break;
1972 }
1973 case LE_STR7('V','a','l','u','e','4','0'): {
1974 value_SetEnum(parent,fasttest_FieldId_Value40); ret = true; break;
1975 }
1976 case LE_STR7('V','a','l','u','e','4','1'): {
1977 value_SetEnum(parent,fasttest_FieldId_Value41); ret = true; break;
1978 }
1979 case LE_STR7('V','a','l','u','e','4','2'): {
1980 value_SetEnum(parent,fasttest_FieldId_Value42); ret = true; break;
1981 }
1982 case LE_STR7('V','a','l','u','e','4','3'): {
1983 value_SetEnum(parent,fasttest_FieldId_Value43); ret = true; break;
1984 }
1985 case LE_STR7('V','a','l','u','e','4','4'): {
1986 value_SetEnum(parent,fasttest_FieldId_Value44); ret = true; break;
1987 }
1988 case LE_STR7('V','a','l','u','e','4','5'): {
1989 value_SetEnum(parent,fasttest_FieldId_Value45); ret = true; break;
1990 }
1991 case LE_STR7('V','a','l','u','e','4','6'): {
1992 value_SetEnum(parent,fasttest_FieldId_Value46); ret = true; break;
1993 }
1994 case LE_STR7('V','a','l','u','e','4','7'): {
1995 value_SetEnum(parent,fasttest_FieldId_Value47); ret = true; break;
1996 }
1997 case LE_STR7('V','a','l','u','e','4','8'): {
1998 value_SetEnum(parent,fasttest_FieldId_Value48); ret = true; break;
1999 }
2000 case LE_STR7('V','a','l','u','e','4','9'): {
2001 value_SetEnum(parent,fasttest_FieldId_Value49); ret = true; break;
2002 }
2003 case LE_STR7('V','a','l','u','e','5','0'): {
2004 value_SetEnum(parent,fasttest_FieldId_Value50); ret = true; break;
2005 }
2006 case LE_STR7('V','a','l','u','e','5','1'): {
2007 value_SetEnum(parent,fasttest_FieldId_Value51); ret = true; break;
2008 }
2009 case LE_STR7('V','a','l','u','e','5','2'): {
2010 value_SetEnum(parent,fasttest_FieldId_Value52); ret = true; break;
2011 }
2012 case LE_STR7('V','a','l','u','e','5','3'): {
2013 value_SetEnum(parent,fasttest_FieldId_Value53); ret = true; break;
2014 }
2015 case LE_STR7('V','a','l','u','e','5','4'): {
2016 value_SetEnum(parent,fasttest_FieldId_Value54); ret = true; break;
2017 }
2018 case LE_STR7('V','a','l','u','e','5','5'): {
2019 value_SetEnum(parent,fasttest_FieldId_Value55); ret = true; break;
2020 }
2021 case LE_STR7('V','a','l','u','e','5','6'): {
2022 value_SetEnum(parent,fasttest_FieldId_Value56); ret = true; break;
2023 }
2024 case LE_STR7('V','a','l','u','e','5','7'): {
2025 value_SetEnum(parent,fasttest_FieldId_Value57); ret = true; break;
2026 }
2027 case LE_STR7('V','a','l','u','e','5','8'): {
2028 value_SetEnum(parent,fasttest_FieldId_Value58); ret = true; break;
2029 }
2030 case LE_STR7('V','a','l','u','e','5','9'): {
2031 value_SetEnum(parent,fasttest_FieldId_Value59); ret = true; break;
2032 }
2033 case LE_STR7('V','a','l','u','e','6','0'): {
2034 value_SetEnum(parent,fasttest_FieldId_Value60); ret = true; break;
2035 }
2036 case LE_STR7('V','a','l','u','e','6','1'): {
2037 value_SetEnum(parent,fasttest_FieldId_Value61); ret = true; break;
2038 }
2039 case LE_STR7('V','a','l','u','e','6','2'): {
2040 value_SetEnum(parent,fasttest_FieldId_Value62); ret = true; break;
2041 }
2042 case LE_STR7('V','a','l','u','e','6','3'): {
2043 value_SetEnum(parent,fasttest_FieldId_Value63); ret = true; break;
2044 }
2045 case LE_STR7('V','a','l','u','e','6','5'): {
2046 value_SetEnum(parent,fasttest_FieldId_Value65); ret = true; break;
2047 }
2048 case LE_STR7('V','a','l','u','e','6','6'): {
2049 value_SetEnum(parent,fasttest_FieldId_Value66); ret = true; break;
2050 }
2051 case LE_STR7('V','a','l','u','e','6','7'): {
2052 value_SetEnum(parent,fasttest_FieldId_Value67); ret = true; break;
2053 }
2054 case LE_STR7('V','a','l','u','e','6','8'): {
2055 value_SetEnum(parent,fasttest_FieldId_Value68); ret = true; break;
2056 }
2057 case LE_STR7('V','a','l','u','e','6','9'): {
2058 value_SetEnum(parent,fasttest_FieldId_Value69); ret = true; break;
2059 }
2060 case LE_STR7('V','a','l','u','e','7','0'): {
2061 value_SetEnum(parent,fasttest_FieldId_Value70); ret = true; break;
2062 }
2063 case LE_STR7('V','a','l','u','e','7','1'): {
2064 value_SetEnum(parent,fasttest_FieldId_Value71); ret = true; break;
2065 }
2066 case LE_STR7('V','a','l','u','e','7','2'): {
2067 value_SetEnum(parent,fasttest_FieldId_Value72); ret = true; break;
2068 }
2069 case LE_STR7('V','a','l','u','e','8','1'): {
2070 value_SetEnum(parent,fasttest_FieldId_Value81); ret = true; break;
2071 }
2072 case LE_STR7('V','a','l','u','e','8','2'): {
2073 value_SetEnum(parent,fasttest_FieldId_Value82); ret = true; break;
2074 }
2075 case LE_STR7('V','a','l','u','e','8','3'): {
2076 value_SetEnum(parent,fasttest_FieldId_Value83); ret = true; break;
2077 }
2078 case LE_STR7('V','a','l','u','e','8','4'): {
2079 value_SetEnum(parent,fasttest_FieldId_Value84); ret = true; break;
2080 }
2081 case LE_STR7('V','a','l','u','e','9','7'): {
2082 value_SetEnum(parent,fasttest_FieldId_Value97); ret = true; break;
2083 }
2084 case LE_STR7('V','a','l','u','e','9','8'): {
2085 value_SetEnum(parent,fasttest_FieldId_Value98); ret = true; break;
2086 }
2087 case LE_STR7('V','a','l','u','e','9','9'): {
2088 value_SetEnum(parent,fasttest_FieldId_Value99); ret = true; break;
2089 }
2090 case LE_STR7('s','e','c','u','n','d','a'): {
2091 value_SetEnum(parent,fasttest_FieldId_secunda); ret = true; break;
2092 }
2093 }
2094 break;
2095 }
2096 case 8: {
2097 switch (algo::ReadLE64(rhs.elems)) {
2098 case LE_STR8('F','i','r','s','t','S','e','q'): {
2099 value_SetEnum(parent,fasttest_FieldId_FirstSeq); ret = true; break;
2100 }
2101 case LE_STR8('V','a','l','u','e','1','0','0'): {
2102 value_SetEnum(parent,fasttest_FieldId_Value100); ret = true; break;
2103 }
2104 case LE_STR8('V','a','l','u','e','1','0','1'): {
2105 value_SetEnum(parent,fasttest_FieldId_Value101); ret = true; break;
2106 }
2107 case LE_STR8('V','a','l','u','e','1','0','2'): {
2108 value_SetEnum(parent,fasttest_FieldId_Value102); ret = true; break;
2109 }
2110 case LE_STR8('V','a','l','u','e','1','0','3'): {
2111 value_SetEnum(parent,fasttest_FieldId_Value103); ret = true; break;
2112 }
2113 case LE_STR8('V','a','l','u','e','1','0','4'): {
2114 value_SetEnum(parent,fasttest_FieldId_Value104); ret = true; break;
2115 }
2116 case LE_STR8('V','a','l','u','e','1','4','7'): {
2117 value_SetEnum(parent,fasttest_FieldId_Value147); ret = true; break;
2118 }
2119 case LE_STR8('V','a','l','u','e','1','5','0'): {
2120 value_SetEnum(parent,fasttest_FieldId_Value150); ret = true; break;
2121 }
2122 }
2123 break;
2124 }
2125 case 9: {
2126 switch (algo::ReadLE64(rhs.elems)) {
2127 case LE_STR8('O','p','t','S','g','m','G','r'): {
2128 if (memcmp(rhs.elems+8,"p",1)==0) { value_SetEnum(parent,fasttest_FieldId_OptSgmGrp); ret = true; break; }
2129 break;
2130 }
2131 case LE_STR8('O','p','t','S','g','m','S','e'): {
2132 if (memcmp(rhs.elems+8,"q",1)==0) { value_SetEnum(parent,fasttest_FieldId_OptSgmSeq); ret = true; break; }
2133 break;
2134 }
2135 case LE_STR8('O','p','t','T','r','v','G','r'): {
2136 if (memcmp(rhs.elems+8,"p",1)==0) { value_SetEnum(parent,fasttest_FieldId_OptTrvGrp); ret = true; break; }
2137 break;
2138 }
2139 case LE_STR8('O','p','t','T','r','v','S','e'): {
2140 if (memcmp(rhs.elems+8,"q",1)==0) { value_SetEnum(parent,fasttest_FieldId_OptTrvSeq); ret = true; break; }
2141 break;
2142 }
2143 case LE_STR8('S','e','c','o','n','d','S','e'): {
2144 if (memcmp(rhs.elems+8,"q",1)==0) { value_SetEnum(parent,fasttest_FieldId_SecondSeq); ret = true; break; }
2145 break;
2146 }
2147 }
2148 break;
2149 }
2150 case 13: {
2151 switch (algo::ReadLE64(rhs.elems)) {
2152 case LE_STR8('T','r','v','S','e','q','D','f'): {
2153 if (memcmp(rhs.elems+8,"ltOpt",5)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqDfltOpt); ret = true; break; }
2154 break;
2155 }
2156 case LE_STR8('T','r','v','S','e','q','L','e'): {
2157 if (memcmp(rhs.elems+8,"nDflt",5)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqLenDflt); ret = true; break; }
2158 if (memcmp(rhs.elems+8,"nNone",5)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqLenNone); ret = true; break; }
2159 break;
2160 }
2161 }
2162 break;
2163 }
2164 case 14: {
2165 switch (algo::ReadLE64(rhs.elems)) {
2166 case LE_STR8('T','r','v','S','e','q','L','e'): {
2167 if (memcmp(rhs.elems+8,"nConst",6)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqLenConst); ret = true; break; }
2168 break;
2169 }
2170 }
2171 break;
2172 }
2173 case 16: {
2174 switch (algo::ReadLE64(rhs.elems)) {
2175 case LE_STR8('T','r','v','S','e','q','L','e'): {
2176 if (memcmp(rhs.elems+8,"nNoneOpt",8)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqLenNoneOpt); ret = true; break; }
2177 break;
2178 }
2179 }
2180 break;
2181 }
2182 case 17: {
2183 switch (algo::ReadLE64(rhs.elems)) {
2184 case LE_STR8('T','r','v','S','e','q','L','e'): {
2185 if (memcmp(rhs.elems+8,"nConstOpt",9)==0) { value_SetEnum(parent,fasttest_FieldId_TrvSeqLenConstOpt); ret = true; break; }
2186 break;
2187 }
2188 }
2189 break;
2190 }
2191 }
2192 return ret;
2193}
2194
2195// --- fasttest.FieldId.value.SetStrptr
2196// Convert string to field.
2197// If the string is invalid, set numeric value to DFLT
2198void fasttest::value_SetStrptr(fasttest::FieldId& parent, algo::strptr rhs, fasttest_FieldIdEnum dflt) {
2199 if (!value_SetStrptrMaybe(parent,rhs)) value_SetEnum(parent,dflt);
2200}
2201
2202// --- fasttest.FieldId.value.ReadStrptrMaybe
2203// Convert string to field. Return success value
2204bool fasttest::value_ReadStrptrMaybe(fasttest::FieldId& parent, algo::strptr rhs) {
2205 bool retval = false;
2206 retval = value_SetStrptrMaybe(parent,rhs); // try symbol conversion
2207 if (!retval) { // didn't work? try reading as underlying type
2208 retval = i32_ReadStrptrMaybe(parent.value,rhs);
2209 }
2210 return retval;
2211}
2212
2213// --- fasttest.FieldId..ReadStrptrMaybe
2214// Read fields of fasttest::FieldId from an ascii string.
2215// The format of the string is the format of the fasttest::FieldId's only field
2216bool fasttest::FieldId_ReadStrptrMaybe(fasttest::FieldId &parent, algo::strptr in_str) {
2217 bool retval = true;
2218 retval = retval && value_ReadStrptrMaybe(parent, in_str);
2219 return retval;
2220}
2221
2222// --- fasttest.FieldId..Print
2223// print string representation of ROW to string STR
2224// cfmt:fasttest.FieldId.String printfmt:Raw
2225void fasttest::FieldId_Print(fasttest::FieldId& row, algo::cstring& str) {
2226 fasttest::value_Print(row, str);
2227}
2228
2229// --- fasttest.FirstSeq..ReadFieldMaybe
2230bool fasttest::FirstSeq_ReadFieldMaybe(fasttest::FirstSeq& parent, algo::strptr field, algo::strptr strval) {
2231 bool retval = true;
2232 fasttest::FieldId field_id;
2233 (void)value_SetStrptrMaybe(field_id,field);
2234 switch(field_id) {
2235 case fasttest_FieldId_Value1: {
2236 retval = u32_ReadStrptrMaybe(parent.Value1, strval);
2237 break;
2238 }
2239 default: break;
2240 }
2241 if (!retval) {
2242 algo_lib::AppendErrtext("attr",field);
2243 }
2244 return retval;
2245}
2246
2247// --- fasttest.FirstSeq..ReadStrptrMaybe
2248// Read fields of fasttest::FirstSeq from an ascii string.
2249// The format of the string is an ssim Tuple
2250bool fasttest::FirstSeq_ReadStrptrMaybe(fasttest::FirstSeq &parent, algo::strptr in_str) {
2251 bool retval = true;
2252 retval = algo::StripTypeTag(in_str, "fasttest.FirstSeq");
2253 ind_beg(algo::Attr_curs, attr, in_str) {
2254 retval = retval && FirstSeq_ReadFieldMaybe(parent, attr.name, attr.value);
2255 }ind_end;
2256 return retval;
2257}
2258
2259// --- fasttest.FirstSeq..Print
2260// print string representation of ROW to string STR
2261// cfmt:fasttest.FirstSeq.String printfmt:Tuple
2262void fasttest::FirstSeq_Print(fasttest::FirstSeq& row, algo::cstring& str) {
2263 algo::tempstr temp;
2264 str << "fasttest.FirstSeq";
2265
2266 u32_Print(row.Value1, temp);
2267 PrintAttrSpaceReset(str,"Value1", temp);
2268}
2269
2270// --- fasttest.FirstSeq..FastEncode
2271void fasttest::FirstSeq_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::FirstSeq& parent) {
2272 // Value1 unsigned none mandatory
2273 lib_fast::EncodeUnsigned(buf,parent.Value1,false);
2274 (void)state;//only to avoid -Wunused-parameter
2275}
2276
2277// --- fasttest.FirstSeq..FastDecode
2278bool fasttest::FirstSeq_FastDecode(algo::memptr& from, FastState& state, fasttest::FirstSeq& parent) {
2279 bool ok = true;
2280 // Value1 unsigned none mandatory
2281 if (ok) {
2282 ok = lib_fast::DecodeUnsigned(from,parent.Value1,false);
2283 if (!ok) {
2284 state.error << "fasttest.FirstSeq.Value1: bad Unsigned" << eol;
2285 }
2286 }
2287 return ok;
2288}
2289
2290// --- fasttest.FirstSeq..FixEncode
2291void fasttest::FirstSeq_FixEncode(cstring& buf, fasttest::FirstSeq& parent, char soh) {
2292 buf << "2=" << parent.Value1 << soh;
2293}
2294
2295// --- fasttest.OptSgmGrp..ReadFieldMaybe
2296bool fasttest::OptSgmGrp_ReadFieldMaybe(fasttest::OptSgmGrp& parent, algo::strptr field, algo::strptr strval) {
2297 bool retval = true;
2298 fasttest::FieldId field_id;
2299 (void)value_SetStrptrMaybe(field_id,field);
2300 switch(field_id) {
2301 case fasttest_FieldId_Value: {
2302 retval = u32_ReadStrptrMaybe(parent.Value, strval);
2303 break;
2304 }
2305 default: break;
2306 }
2307 if (!retval) {
2308 algo_lib::AppendErrtext("attr",field);
2309 }
2310 return retval;
2311}
2312
2313// --- fasttest.OptSgmGrp..ReadStrptrMaybe
2314// Read fields of fasttest::OptSgmGrp from an ascii string.
2315// The format of the string is an ssim Tuple
2316bool fasttest::OptSgmGrp_ReadStrptrMaybe(fasttest::OptSgmGrp &parent, algo::strptr in_str) {
2317 bool retval = true;
2318 retval = algo::StripTypeTag(in_str, "fasttest.OptSgmGrp");
2319 ind_beg(algo::Attr_curs, attr, in_str) {
2320 retval = retval && OptSgmGrp_ReadFieldMaybe(parent, attr.name, attr.value);
2321 }ind_end;
2322 return retval;
2323}
2324
2325// --- fasttest.OptSgmGrp..Print
2326// print string representation of ROW to string STR
2327// cfmt:fasttest.OptSgmGrp.String printfmt:Tuple
2328void fasttest::OptSgmGrp_Print(fasttest::OptSgmGrp& row, algo::cstring& str) {
2329 algo::tempstr temp;
2330 str << "fasttest.OptSgmGrp";
2331
2332 u32_Print(row.Value, temp);
2333 PrintAttrSpaceReset(str,"Value", temp);
2334}
2335
2336// --- fasttest.OptSgmGrp..FastEncode
2337void fasttest::OptSgmGrp_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::OptSgmGrp& parent) {
2338 int index = ary_N(buf);
2339 u64 pmap(0);
2340 // Value unsigned default mandatory
2341 if (parent.Value != 1) {
2342 lib_fast::EncodeUnsigned(buf,parent.Value,false);
2343 lib_fast::SetPmapBit(pmap,0);
2344 }
2345 lib_fast::InsertPmap(buf,index,pmap);
2346 (void)state;//only to avoid -Wunused-parameter
2347}
2348
2349// --- fasttest.OptSgmGrp..FastDecode
2350bool fasttest::OptSgmGrp_FastDecode(algo::memptr& from, FastState& state, fasttest::OptSgmGrp& parent) {
2351 bool ok = true;
2352 u64 pmap;
2353 ok = lib_fast::DecodePmap(from,pmap);
2354 if (!ok) {
2355 state.error << "fasttest.OptSgmGrp: bad pmap" << eol;
2356 }
2357 // Value unsigned default mandatory
2358 if (ok) {
2359 bool prs = lib_fast::GetPmapBit(pmap,0);
2360 if (prs) {
2361 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
2362 if (!ok) {
2363 state.error << "fasttest.OptSgmGrp.Value: bad Unsigned" << eol;
2364 }
2365 } else {
2366 parent.Value = 1;
2367 }
2368 }
2369 return ok;
2370}
2371
2372// --- fasttest.OptSgmGrp..FixEncode
2373void fasttest::OptSgmGrp_FixEncode(cstring& buf, fasttest::OptSgmGrp& parent, char soh) {
2374 buf << "2=" << parent.Value << soh;
2375}
2376
2377// --- fasttest.GroupSgmOpt.base.CopyOut
2378// Copy fields out of row
2379void fasttest::parent_CopyOut(fasttest::GroupSgmOpt &row, fasttest::TemplateHeader &out) {
2380 // length: field value is computed
2381 // id: field value is computed
2382 (void)row;//only to avoid -Wunused-parameter
2383 (void)out;//only to avoid -Wunused-parameter
2384}
2385
2386// --- fasttest.GroupSgmOpt.OptSgmGrp.ReadStrptrMaybe
2387inline static bool fasttest::OptSgmGrp_ReadStrptrMaybe(fasttest::GroupSgmOpt &parent, algo::strptr in_str) {
2388 bool retval = true;
2389 fasttest::OptSgmGrp OptSgmGrp_tmp;
2390 retval = fasttest::OptSgmGrp_ReadStrptrMaybe(OptSgmGrp_tmp, in_str);
2391 if (retval) {
2392 OptSgmGrp_Set(parent, OptSgmGrp_tmp);
2393 }
2394 return retval;
2395}
2396
2397// --- fasttest.GroupSgmOpt.pmask_bitcurs.Next
2398// proceed to next item
2399void fasttest::GroupSgmOpt_pmask_bitcurs_Next(GroupSgmOpt_pmask_bitcurs &curs) {
2400 ++curs.bit;
2401 int index = curs.bit / 32;
2402 int offset = curs.bit % 32;
2403 for (; index < curs.n_elems; ++index, offset = 0) {
2404 u64 rest = curs.elems[index] >> offset;
2405 if (rest) {
2406 offset += algo::u64_BitScanForward(rest);
2407 break;
2408 }
2409 }
2410 curs.bit = index * 32 + offset;
2411}
2412
2413// --- fasttest.GroupSgmOpt..ReadFieldMaybe
2414bool fasttest::GroupSgmOpt_ReadFieldMaybe(fasttest::GroupSgmOpt& parent, algo::strptr field, algo::strptr strval) {
2415 bool retval = true;
2416 fasttest::FieldId field_id;
2417 (void)value_SetStrptrMaybe(field_id,field);
2418 switch(field_id) {
2419 case fasttest_FieldId_base: {
2420 retval = false;
2421 break;
2422 }
2423 case fasttest_FieldId_length: {
2424 retval = false;
2425 break;
2426 }
2427 case fasttest_FieldId_id: {
2428 retval = false;
2429 break;
2430 }
2431 case fasttest_FieldId_pmask: {
2432 retval = false;
2433 break;
2434 }
2435 case fasttest_FieldId_OptSgmGrp: {
2436 retval = OptSgmGrp_ReadStrptrMaybe(parent, strval);
2437 if (retval) {
2438 pmask_qSetBit(parent, 0);
2439 }
2440 break;
2441 }
2442 default: break;
2443 }
2444 if (!retval) {
2445 algo_lib::AppendErrtext("attr",field);
2446 }
2447 return retval;
2448}
2449
2450// --- fasttest.GroupSgmOpt..ReadStrptrMaybe
2451// Read fields of fasttest::GroupSgmOpt from an ascii string.
2452// The format of the string is an ssim Tuple
2453bool fasttest::GroupSgmOpt_ReadStrptrMaybe(fasttest::GroupSgmOpt &parent, algo::strptr in_str) {
2454 bool retval = true;
2455 retval = algo::StripTypeTag(in_str, "fasttest.GroupSgmOpt");
2456 ind_beg(algo::Attr_curs, attr, in_str) {
2457 retval = retval && GroupSgmOpt_ReadFieldMaybe(parent, attr.name, attr.value);
2458 }ind_end;
2459 return retval;
2460}
2461
2462// --- fasttest.GroupSgmOpt..Print
2463// print string representation of ROW to string STR
2464// cfmt:fasttest.GroupSgmOpt.String printfmt:Tuple
2465void fasttest::GroupSgmOpt_Print(fasttest::GroupSgmOpt& row, algo::cstring& str) {
2466 algo::tempstr temp;
2467 str << "fasttest.GroupSgmOpt";
2468
2469 if (OptSgmGrp_PresentQ(row)) {
2470 fasttest::OptSgmGrp_Print(row.OptSgmGrp, temp);
2471 PrintAttrSpaceReset(str,"OptSgmGrp", temp);
2472 }
2473}
2474
2475// --- fasttest.GroupSgmOpt..FastEncode
2476void fasttest::GroupSgmOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::GroupSgmOpt& parent) {
2477 int index = ary_N(buf);
2478 u64 pmap(0);
2479 if (!tid_AssignedQ(state) || parent.id != state.tid) {
2480 lib_fast::EncodeUnsigned(buf,parent.id,false);
2481 lib_fast::SetPmapBit(pmap,0);
2482 }
2483 tid_SetAssigned(state);
2484 state.tid = parent.id;
2485 // OptSgmGrp group none optional
2486 if (OptSgmGrp_PresentQ(parent)) {
2487 OptSgmGrp_FastEncode(buf,state,parent.OptSgmGrp);
2488 lib_fast::SetPmapBit(pmap,1);
2489 }
2490 lib_fast::InsertPmap(buf,index,pmap);
2491}
2492
2493// --- fasttest.GroupSgmOpt..FastDecode
2494bool fasttest::GroupSgmOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::GroupSgmOpt& parent) {
2495 bool ok = true;
2496 // OptSgmGrp group none optional
2497 if (ok) {
2498 bool prs = lib_fast::GetPmapBit(pmap,1);
2499 pmask_qSetBitVal(parent,OptSgmGrp_Present_GetBit(parent),prs);
2500 if (prs) {
2501 ok = OptSgmGrp_FastDecode(from,state,parent.OptSgmGrp);
2502 }
2503 }
2504 return ok;
2505}
2506
2507// --- fasttest.GroupSgmOpt..FixEncode
2508void fasttest::GroupSgmOpt_FixEncode(cstring& buf, fasttest::GroupSgmOpt& parent, char soh) {
2509 if (OptSgmGrp_PresentQ(parent)) {
2510 OptSgmGrp_FixEncode(buf,parent.OptSgmGrp,soh);
2511 }
2512}
2513
2514// --- fasttest.TrvGrp..ReadFieldMaybe
2515bool fasttest::TrvGrp_ReadFieldMaybe(fasttest::TrvGrp& parent, algo::strptr field, algo::strptr strval) {
2516 bool retval = true;
2517 fasttest::FieldId field_id;
2518 (void)value_SetStrptrMaybe(field_id,field);
2519 switch(field_id) {
2520 case fasttest_FieldId_Value: {
2521 retval = u32_ReadStrptrMaybe(parent.Value, strval);
2522 break;
2523 }
2524 default: break;
2525 }
2526 if (!retval) {
2527 algo_lib::AppendErrtext("attr",field);
2528 }
2529 return retval;
2530}
2531
2532// --- fasttest.TrvGrp..ReadStrptrMaybe
2533// Read fields of fasttest::TrvGrp from an ascii string.
2534// The format of the string is an ssim Tuple
2535bool fasttest::TrvGrp_ReadStrptrMaybe(fasttest::TrvGrp &parent, algo::strptr in_str) {
2536 bool retval = true;
2537 retval = algo::StripTypeTag(in_str, "fasttest.TrvGrp");
2538 ind_beg(algo::Attr_curs, attr, in_str) {
2539 retval = retval && TrvGrp_ReadFieldMaybe(parent, attr.name, attr.value);
2540 }ind_end;
2541 return retval;
2542}
2543
2544// --- fasttest.TrvGrp..Print
2545// print string representation of ROW to string STR
2546// cfmt:fasttest.TrvGrp.String printfmt:Tuple
2547void fasttest::TrvGrp_Print(fasttest::TrvGrp& row, algo::cstring& str) {
2548 algo::tempstr temp;
2549 str << "fasttest.TrvGrp";
2550
2551 u32_Print(row.Value, temp);
2552 PrintAttrSpaceReset(str,"Value", temp);
2553}
2554
2555// --- fasttest.TrvGrp..FastEncode
2556void fasttest::TrvGrp_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvGrp& parent) {
2557 // Value unsigned none mandatory
2558 lib_fast::EncodeUnsigned(buf,parent.Value,false);
2559 (void)state;//only to avoid -Wunused-parameter
2560}
2561
2562// --- fasttest.TrvGrp..FastDecode
2563bool fasttest::TrvGrp_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvGrp& parent) {
2564 bool ok = true;
2565 // Value unsigned none mandatory
2566 if (ok) {
2567 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
2568 if (!ok) {
2569 state.error << "fasttest.TrvGrp.Value: bad Unsigned" << eol;
2570 }
2571 }
2572 return ok;
2573}
2574
2575// --- fasttest.TrvGrp..FixEncode
2576void fasttest::TrvGrp_FixEncode(cstring& buf, fasttest::TrvGrp& parent, char soh) {
2577 buf << "2=" << parent.Value << soh;
2578}
2579
2580// --- fasttest.GroupTrv.base.CopyOut
2581// Copy fields out of row
2582void fasttest::parent_CopyOut(fasttest::GroupTrv &row, fasttest::TemplateHeader &out) {
2583 // length: field value is computed
2584 // id: field value is computed
2585 (void)row;//only to avoid -Wunused-parameter
2586 (void)out;//only to avoid -Wunused-parameter
2587}
2588
2589// --- fasttest.GroupTrv..ReadFieldMaybe
2590bool fasttest::GroupTrv_ReadFieldMaybe(fasttest::GroupTrv& parent, algo::strptr field, algo::strptr strval) {
2591 bool retval = true;
2592 fasttest::FieldId field_id;
2593 (void)value_SetStrptrMaybe(field_id,field);
2594 switch(field_id) {
2595 case fasttest_FieldId_base: {
2596 retval = false;
2597 break;
2598 }
2599 case fasttest_FieldId_length: {
2600 retval = false;
2601 break;
2602 }
2603 case fasttest_FieldId_id: {
2604 retval = false;
2605 break;
2606 }
2607 case fasttest_FieldId_TrvGrp: {
2608 retval = fasttest::TrvGrp_ReadStrptrMaybe(parent.TrvGrp, strval);
2609 break;
2610 }
2611 default: break;
2612 }
2613 if (!retval) {
2614 algo_lib::AppendErrtext("attr",field);
2615 }
2616 return retval;
2617}
2618
2619// --- fasttest.GroupTrv..ReadStrptrMaybe
2620// Read fields of fasttest::GroupTrv from an ascii string.
2621// The format of the string is an ssim Tuple
2622bool fasttest::GroupTrv_ReadStrptrMaybe(fasttest::GroupTrv &parent, algo::strptr in_str) {
2623 bool retval = true;
2624 retval = algo::StripTypeTag(in_str, "fasttest.GroupTrv");
2625 ind_beg(algo::Attr_curs, attr, in_str) {
2626 retval = retval && GroupTrv_ReadFieldMaybe(parent, attr.name, attr.value);
2627 }ind_end;
2628 return retval;
2629}
2630
2631// --- fasttest.GroupTrv..Print
2632// print string representation of ROW to string STR
2633// cfmt:fasttest.GroupTrv.String printfmt:Tuple
2634void fasttest::GroupTrv_Print(fasttest::GroupTrv& row, algo::cstring& str) {
2635 algo::tempstr temp;
2636 str << "fasttest.GroupTrv";
2637
2638 fasttest::TrvGrp_Print(row.TrvGrp, temp);
2639 PrintAttrSpaceReset(str,"TrvGrp", temp);
2640}
2641
2642// --- fasttest.GroupTrv..FastEncode
2643void fasttest::GroupTrv_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::GroupTrv& parent) {
2644 int index = ary_N(buf);
2645 u64 pmap(0);
2646 if (!tid_AssignedQ(state) || parent.id != state.tid) {
2647 lib_fast::EncodeUnsigned(buf,parent.id,false);
2648 lib_fast::SetPmapBit(pmap,0);
2649 }
2650 tid_SetAssigned(state);
2651 state.tid = parent.id;
2652 // TrvGrp group none mandatory
2653 TrvGrp_FastEncode(buf,state,parent.TrvGrp);
2654 lib_fast::InsertPmap(buf,index,pmap);
2655}
2656
2657// --- fasttest.GroupTrv..FastDecode
2658bool fasttest::GroupTrv_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::GroupTrv& parent) {
2659 bool ok = true;
2660 // TrvGrp group none mandatory
2661 if (ok) {
2662 ok = TrvGrp_FastDecode(from,state,parent.TrvGrp);
2663 }
2664 (void)pmap;//only to avoid -Wunused-parameter
2665 return ok;
2666}
2667
2668// --- fasttest.GroupTrv..FixEncode
2669void fasttest::GroupTrv_FixEncode(cstring& buf, fasttest::GroupTrv& parent, char soh) {
2670 TrvGrp_FixEncode(buf,parent.TrvGrp, soh);
2671}
2672
2673// --- fasttest.OptTrvGrp..ReadFieldMaybe
2674bool fasttest::OptTrvGrp_ReadFieldMaybe(fasttest::OptTrvGrp& parent, algo::strptr field, algo::strptr strval) {
2675 bool retval = true;
2676 fasttest::FieldId field_id;
2677 (void)value_SetStrptrMaybe(field_id,field);
2678 switch(field_id) {
2679 case fasttest_FieldId_Value: {
2680 retval = u32_ReadStrptrMaybe(parent.Value, strval);
2681 break;
2682 }
2683 default: break;
2684 }
2685 if (!retval) {
2686 algo_lib::AppendErrtext("attr",field);
2687 }
2688 return retval;
2689}
2690
2691// --- fasttest.OptTrvGrp..ReadStrptrMaybe
2692// Read fields of fasttest::OptTrvGrp from an ascii string.
2693// The format of the string is an ssim Tuple
2694bool fasttest::OptTrvGrp_ReadStrptrMaybe(fasttest::OptTrvGrp &parent, algo::strptr in_str) {
2695 bool retval = true;
2696 retval = algo::StripTypeTag(in_str, "fasttest.OptTrvGrp");
2697 ind_beg(algo::Attr_curs, attr, in_str) {
2698 retval = retval && OptTrvGrp_ReadFieldMaybe(parent, attr.name, attr.value);
2699 }ind_end;
2700 return retval;
2701}
2702
2703// --- fasttest.OptTrvGrp..Print
2704// print string representation of ROW to string STR
2705// cfmt:fasttest.OptTrvGrp.String printfmt:Tuple
2706void fasttest::OptTrvGrp_Print(fasttest::OptTrvGrp& row, algo::cstring& str) {
2707 algo::tempstr temp;
2708 str << "fasttest.OptTrvGrp";
2709
2710 u32_Print(row.Value, temp);
2711 PrintAttrSpaceReset(str,"Value", temp);
2712}
2713
2714// --- fasttest.OptTrvGrp..FastEncode
2715void fasttest::OptTrvGrp_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::OptTrvGrp& parent) {
2716 // Value unsigned none mandatory
2717 lib_fast::EncodeUnsigned(buf,parent.Value,false);
2718 (void)state;//only to avoid -Wunused-parameter
2719}
2720
2721// --- fasttest.OptTrvGrp..FastDecode
2722bool fasttest::OptTrvGrp_FastDecode(algo::memptr& from, FastState& state, fasttest::OptTrvGrp& parent) {
2723 bool ok = true;
2724 // Value unsigned none mandatory
2725 if (ok) {
2726 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
2727 if (!ok) {
2728 state.error << "fasttest.OptTrvGrp.Value: bad Unsigned" << eol;
2729 }
2730 }
2731 return ok;
2732}
2733
2734// --- fasttest.OptTrvGrp..FixEncode
2735void fasttest::OptTrvGrp_FixEncode(cstring& buf, fasttest::OptTrvGrp& parent, char soh) {
2736 buf << "2=" << parent.Value << soh;
2737}
2738
2739// --- fasttest.GroupTrvOpt.base.CopyOut
2740// Copy fields out of row
2741void fasttest::parent_CopyOut(fasttest::GroupTrvOpt &row, fasttest::TemplateHeader &out) {
2742 // length: field value is computed
2743 // id: field value is computed
2744 (void)row;//only to avoid -Wunused-parameter
2745 (void)out;//only to avoid -Wunused-parameter
2746}
2747
2748// --- fasttest.GroupTrvOpt.OptTrvGrp.ReadStrptrMaybe
2749inline static bool fasttest::OptTrvGrp_ReadStrptrMaybe(fasttest::GroupTrvOpt &parent, algo::strptr in_str) {
2750 bool retval = true;
2751 fasttest::OptTrvGrp OptTrvGrp_tmp;
2752 retval = fasttest::OptTrvGrp_ReadStrptrMaybe(OptTrvGrp_tmp, in_str);
2753 if (retval) {
2754 OptTrvGrp_Set(parent, OptTrvGrp_tmp);
2755 }
2756 return retval;
2757}
2758
2759// --- fasttest.GroupTrvOpt.pmask_bitcurs.Next
2760// proceed to next item
2761void fasttest::GroupTrvOpt_pmask_bitcurs_Next(GroupTrvOpt_pmask_bitcurs &curs) {
2762 ++curs.bit;
2763 int index = curs.bit / 32;
2764 int offset = curs.bit % 32;
2765 for (; index < curs.n_elems; ++index, offset = 0) {
2766 u64 rest = curs.elems[index] >> offset;
2767 if (rest) {
2768 offset += algo::u64_BitScanForward(rest);
2769 break;
2770 }
2771 }
2772 curs.bit = index * 32 + offset;
2773}
2774
2775// --- fasttest.GroupTrvOpt..ReadFieldMaybe
2776bool fasttest::GroupTrvOpt_ReadFieldMaybe(fasttest::GroupTrvOpt& parent, algo::strptr field, algo::strptr strval) {
2777 bool retval = true;
2778 fasttest::FieldId field_id;
2779 (void)value_SetStrptrMaybe(field_id,field);
2780 switch(field_id) {
2781 case fasttest_FieldId_base: {
2782 retval = false;
2783 break;
2784 }
2785 case fasttest_FieldId_length: {
2786 retval = false;
2787 break;
2788 }
2789 case fasttest_FieldId_id: {
2790 retval = false;
2791 break;
2792 }
2793 case fasttest_FieldId_pmask: {
2794 retval = false;
2795 break;
2796 }
2797 case fasttest_FieldId_OptTrvGrp: {
2798 retval = OptTrvGrp_ReadStrptrMaybe(parent, strval);
2799 if (retval) {
2800 pmask_qSetBit(parent, 0);
2801 }
2802 break;
2803 }
2804 default: break;
2805 }
2806 if (!retval) {
2807 algo_lib::AppendErrtext("attr",field);
2808 }
2809 return retval;
2810}
2811
2812// --- fasttest.GroupTrvOpt..ReadStrptrMaybe
2813// Read fields of fasttest::GroupTrvOpt from an ascii string.
2814// The format of the string is an ssim Tuple
2815bool fasttest::GroupTrvOpt_ReadStrptrMaybe(fasttest::GroupTrvOpt &parent, algo::strptr in_str) {
2816 bool retval = true;
2817 retval = algo::StripTypeTag(in_str, "fasttest.GroupTrvOpt");
2818 ind_beg(algo::Attr_curs, attr, in_str) {
2819 retval = retval && GroupTrvOpt_ReadFieldMaybe(parent, attr.name, attr.value);
2820 }ind_end;
2821 return retval;
2822}
2823
2824// --- fasttest.GroupTrvOpt..Print
2825// print string representation of ROW to string STR
2826// cfmt:fasttest.GroupTrvOpt.String printfmt:Tuple
2827void fasttest::GroupTrvOpt_Print(fasttest::GroupTrvOpt& row, algo::cstring& str) {
2828 algo::tempstr temp;
2829 str << "fasttest.GroupTrvOpt";
2830
2831 if (OptTrvGrp_PresentQ(row)) {
2832 fasttest::OptTrvGrp_Print(row.OptTrvGrp, temp);
2833 PrintAttrSpaceReset(str,"OptTrvGrp", temp);
2834 }
2835}
2836
2837// --- fasttest.GroupTrvOpt..FastEncode
2838void fasttest::GroupTrvOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::GroupTrvOpt& parent) {
2839 int index = ary_N(buf);
2840 u64 pmap(0);
2841 if (!tid_AssignedQ(state) || parent.id != state.tid) {
2842 lib_fast::EncodeUnsigned(buf,parent.id,false);
2843 lib_fast::SetPmapBit(pmap,0);
2844 }
2845 tid_SetAssigned(state);
2846 state.tid = parent.id;
2847 // OptTrvGrp group none optional
2848 if (OptTrvGrp_PresentQ(parent)) {
2849 OptTrvGrp_FastEncode(buf,state,parent.OptTrvGrp);
2850 lib_fast::SetPmapBit(pmap,1);
2851 }
2852 lib_fast::InsertPmap(buf,index,pmap);
2853}
2854
2855// --- fasttest.GroupTrvOpt..FastDecode
2856bool fasttest::GroupTrvOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::GroupTrvOpt& parent) {
2857 bool ok = true;
2858 // OptTrvGrp group none optional
2859 if (ok) {
2860 bool prs = lib_fast::GetPmapBit(pmap,1);
2861 pmask_qSetBitVal(parent,OptTrvGrp_Present_GetBit(parent),prs);
2862 if (prs) {
2863 ok = OptTrvGrp_FastDecode(from,state,parent.OptTrvGrp);
2864 }
2865 }
2866 return ok;
2867}
2868
2869// --- fasttest.GroupTrvOpt..FixEncode
2870void fasttest::GroupTrvOpt_FixEncode(cstring& buf, fasttest::GroupTrvOpt& parent, char soh) {
2871 if (OptTrvGrp_PresentQ(parent)) {
2872 OptTrvGrp_FixEncode(buf,parent.OptTrvGrp,soh);
2873 }
2874}
2875
2876// --- fasttest.I32Const.base.CopyOut
2877// Copy fields out of row
2878void fasttest::parent_CopyOut(fasttest::I32Const &row, fasttest::TemplateHeader &out) {
2879 // length: field value is computed
2880 // id: field value is computed
2881 (void)row;//only to avoid -Wunused-parameter
2882 (void)out;//only to avoid -Wunused-parameter
2883}
2884
2885// --- fasttest.I32Const..ReadFieldMaybe
2886bool fasttest::I32Const_ReadFieldMaybe(fasttest::I32Const& parent, algo::strptr field, algo::strptr strval) {
2887 bool retval = true;
2888 fasttest::FieldId field_id;
2889 (void)value_SetStrptrMaybe(field_id,field);
2890 switch(field_id) {
2891 case fasttest_FieldId_base: {
2892 retval = false;
2893 break;
2894 }
2895 case fasttest_FieldId_length: {
2896 retval = false;
2897 break;
2898 }
2899 case fasttest_FieldId_id: {
2900 retval = false;
2901 break;
2902 }
2903 case fasttest_FieldId_Value: {
2904 retval = true;
2905 break;
2906 }
2907 default: break;
2908 }
2909 if (!retval) {
2910 algo_lib::AppendErrtext("attr",field);
2911 }
2912 (void)parent;//only to avoid -Wunused-parameter
2913 (void)strval;//only to avoid -Wunused-parameter
2914 return retval;
2915}
2916
2917// --- fasttest.I32Const..ReadStrptrMaybe
2918// Read fields of fasttest::I32Const from an ascii string.
2919// The format of the string is an ssim Tuple
2920bool fasttest::I32Const_ReadStrptrMaybe(fasttest::I32Const &parent, algo::strptr in_str) {
2921 bool retval = true;
2922 retval = algo::StripTypeTag(in_str, "fasttest.I32Const");
2923 ind_beg(algo::Attr_curs, attr, in_str) {
2924 retval = retval && I32Const_ReadFieldMaybe(parent, attr.name, attr.value);
2925 }ind_end;
2926 return retval;
2927}
2928
2929// --- fasttest.I32Const..Print
2930// print string representation of ROW to string STR
2931// cfmt:fasttest.I32Const.String printfmt:Tuple
2932void fasttest::I32Const_Print(fasttest::I32Const& row, algo::cstring& str) {
2933 algo::tempstr temp;
2934 str << "fasttest.I32Const";
2935
2936 i32_Print(Value_Get(row), temp);
2937 PrintAttrSpaceReset(str,"Value", temp);
2938}
2939
2940// --- fasttest.I32Const..FastEncode
2941void fasttest::I32Const_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32Const& parent) {
2942 int index = ary_N(buf);
2943 u64 pmap(0);
2944 if (!tid_AssignedQ(state) || parent.id != state.tid) {
2945 lib_fast::EncodeUnsigned(buf,parent.id,false);
2946 lib_fast::SetPmapBit(pmap,0);
2947 }
2948 tid_SetAssigned(state);
2949 state.tid = parent.id;
2950 // Value signed constant mandatory
2951 lib_fast::InsertPmap(buf,index,pmap);
2952}
2953
2954// --- fasttest.I32Const..FastDecode
2955bool fasttest::I32Const_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32Const& parent) {
2956 bool ok = true;
2957 // Value signed constant mandatory
2958 if (ok) {
2959 }
2960 (void)from;//only to avoid -Wunused-parameter
2961 (void)pmap;//only to avoid -Wunused-parameter
2962 (void)state;//only to avoid -Wunused-parameter
2963 (void)parent;//only to avoid -Wunused-parameter
2964 return ok;
2965}
2966
2967// --- fasttest.I32Const..FixEncode
2968void fasttest::I32Const_FixEncode(cstring& buf, fasttest::I32Const& parent, char soh) {
2969 buf << "1=" << Value_Get(parent) << soh;
2970}
2971
2972// --- fasttest.I32ConstOpt.base.CopyOut
2973// Copy fields out of row
2974void fasttest::parent_CopyOut(fasttest::I32ConstOpt &row, fasttest::TemplateHeader &out) {
2975 // length: field value is computed
2976 // id: field value is computed
2977 (void)row;//only to avoid -Wunused-parameter
2978 (void)out;//only to avoid -Wunused-parameter
2979}
2980
2981// --- fasttest.I32ConstOpt.pmask_bitcurs.Next
2982// proceed to next item
2983void fasttest::I32ConstOpt_pmask_bitcurs_Next(I32ConstOpt_pmask_bitcurs &curs) {
2984 ++curs.bit;
2985 int index = curs.bit / 32;
2986 int offset = curs.bit % 32;
2987 for (; index < curs.n_elems; ++index, offset = 0) {
2988 u64 rest = curs.elems[index] >> offset;
2989 if (rest) {
2990 offset += algo::u64_BitScanForward(rest);
2991 break;
2992 }
2993 }
2994 curs.bit = index * 32 + offset;
2995}
2996
2997// --- fasttest.I32ConstOpt..ReadFieldMaybe
2998bool fasttest::I32ConstOpt_ReadFieldMaybe(fasttest::I32ConstOpt& parent, algo::strptr field, algo::strptr strval) {
2999 bool retval = true;
3000 fasttest::FieldId field_id;
3001 (void)value_SetStrptrMaybe(field_id,field);
3002 switch(field_id) {
3003 case fasttest_FieldId_base: {
3004 retval = false;
3005 break;
3006 }
3007 case fasttest_FieldId_length: {
3008 retval = false;
3009 break;
3010 }
3011 case fasttest_FieldId_id: {
3012 retval = false;
3013 break;
3014 }
3015 case fasttest_FieldId_pmask: {
3016 retval = false;
3017 break;
3018 }
3019 case fasttest_FieldId_Value: {
3020 retval = true;
3021 if (retval) {
3022 pmask_qSetBit(parent, 0);
3023 }
3024 break;
3025 }
3026 default: break;
3027 }
3028 if (!retval) {
3029 algo_lib::AppendErrtext("attr",field);
3030 }
3031 (void)strval;//only to avoid -Wunused-parameter
3032 return retval;
3033}
3034
3035// --- fasttest.I32ConstOpt..ReadStrptrMaybe
3036// Read fields of fasttest::I32ConstOpt from an ascii string.
3037// The format of the string is an ssim Tuple
3038bool fasttest::I32ConstOpt_ReadStrptrMaybe(fasttest::I32ConstOpt &parent, algo::strptr in_str) {
3039 bool retval = true;
3040 retval = algo::StripTypeTag(in_str, "fasttest.I32ConstOpt");
3041 ind_beg(algo::Attr_curs, attr, in_str) {
3042 retval = retval && I32ConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
3043 }ind_end;
3044 return retval;
3045}
3046
3047// --- fasttest.I32ConstOpt..Print
3048// print string representation of ROW to string STR
3049// cfmt:fasttest.I32ConstOpt.String printfmt:Tuple
3050void fasttest::I32ConstOpt_Print(fasttest::I32ConstOpt& row, algo::cstring& str) {
3051 algo::tempstr temp;
3052 str << "fasttest.I32ConstOpt";
3053
3054 if (Value_PresentQ(row)) {
3055 i32_Print(Value_Get(row), temp);
3056 PrintAttrSpaceReset(str,"Value", temp);
3057 }
3058}
3059
3060// --- fasttest.I32ConstOpt..FastEncode
3061void fasttest::I32ConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32ConstOpt& parent) {
3062 int index = ary_N(buf);
3063 u64 pmap(0);
3064 if (!tid_AssignedQ(state) || parent.id != state.tid) {
3065 lib_fast::EncodeUnsigned(buf,parent.id,false);
3066 lib_fast::SetPmapBit(pmap,0);
3067 }
3068 tid_SetAssigned(state);
3069 state.tid = parent.id;
3070 // Value signed constant optional
3071 if (Value_PresentQ(parent)) {
3072 lib_fast::SetPmapBit(pmap,1);
3073 }
3074 lib_fast::InsertPmap(buf,index,pmap);
3075}
3076
3077// --- fasttest.I32ConstOpt..FastDecode
3078bool fasttest::I32ConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32ConstOpt& parent) {
3079 bool ok = true;
3080 // Value signed constant optional
3081 if (ok) {
3082 bool prs = lib_fast::GetPmapBit(pmap,1);
3083 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
3084 }
3085 (void)from;//only to avoid -Wunused-parameter
3086 (void)state;//only to avoid -Wunused-parameter
3087 return ok;
3088}
3089
3090// --- fasttest.I32ConstOpt..FixEncode
3091void fasttest::I32ConstOpt_FixEncode(cstring& buf, fasttest::I32ConstOpt& parent, char soh) {
3092 if (Value_PresentQ(parent)) {
3093 buf << "1=" << Value_Get(parent) << soh;
3094 }
3095}
3096
3097// --- fasttest.I32Copy.base.CopyOut
3098// Copy fields out of row
3099void fasttest::parent_CopyOut(fasttest::I32Copy &row, fasttest::TemplateHeader &out) {
3100 // length: field value is computed
3101 // id: field value is computed
3102 (void)row;//only to avoid -Wunused-parameter
3103 (void)out;//only to avoid -Wunused-parameter
3104}
3105
3106// --- fasttest.I32Copy..ReadFieldMaybe
3107bool fasttest::I32Copy_ReadFieldMaybe(fasttest::I32Copy& parent, algo::strptr field, algo::strptr strval) {
3108 bool retval = true;
3109 fasttest::FieldId field_id;
3110 (void)value_SetStrptrMaybe(field_id,field);
3111 switch(field_id) {
3112 case fasttest_FieldId_base: {
3113 retval = false;
3114 break;
3115 }
3116 case fasttest_FieldId_length: {
3117 retval = false;
3118 break;
3119 }
3120 case fasttest_FieldId_id: {
3121 retval = false;
3122 break;
3123 }
3124 case fasttest_FieldId_Value49: {
3125 retval = i32_ReadStrptrMaybe(parent.Value49, strval);
3126 break;
3127 }
3128 default: break;
3129 }
3130 if (!retval) {
3131 algo_lib::AppendErrtext("attr",field);
3132 }
3133 return retval;
3134}
3135
3136// --- fasttest.I32Copy..ReadStrptrMaybe
3137// Read fields of fasttest::I32Copy from an ascii string.
3138// The format of the string is an ssim Tuple
3139bool fasttest::I32Copy_ReadStrptrMaybe(fasttest::I32Copy &parent, algo::strptr in_str) {
3140 bool retval = true;
3141 retval = algo::StripTypeTag(in_str, "fasttest.I32Copy");
3142 ind_beg(algo::Attr_curs, attr, in_str) {
3143 retval = retval && I32Copy_ReadFieldMaybe(parent, attr.name, attr.value);
3144 }ind_end;
3145 return retval;
3146}
3147
3148// --- fasttest.I32Copy..Print
3149// print string representation of ROW to string STR
3150// cfmt:fasttest.I32Copy.String printfmt:Tuple
3151void fasttest::I32Copy_Print(fasttest::I32Copy& row, algo::cstring& str) {
3152 algo::tempstr temp;
3153 str << "fasttest.I32Copy";
3154
3155 i32_Print(row.Value49, temp);
3156 PrintAttrSpaceReset(str,"Value49", temp);
3157}
3158
3159// --- fasttest.I32Copy..FastEncode
3160void fasttest::I32Copy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32Copy& parent) {
3161 int index = ary_N(buf);
3162 u64 pmap(0);
3163 if (!tid_AssignedQ(state) || parent.id != state.tid) {
3164 lib_fast::EncodeUnsigned(buf,parent.id,false);
3165 lib_fast::SetPmapBit(pmap,0);
3166 }
3167 tid_SetAssigned(state);
3168 state.tid = parent.id;
3169 // Value49 signed copy mandatory
3170 if (Value49_AssignedQ(state) ? parent.Value49 != state.Value49 : parent.Value49 != 49) {
3171 lib_fast::EncodeSigned(buf,parent.Value49,false);
3172 lib_fast::SetPmapBit(pmap,1);
3173 }
3174 state.Value49 = parent.Value49;
3175 Value49_SetAssigned(state);
3176 lib_fast::InsertPmap(buf,index,pmap);
3177}
3178
3179// --- fasttest.I32Copy..FastDecode
3180bool fasttest::I32Copy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32Copy& parent) {
3181 bool ok = true;
3182 // Value49 signed copy mandatory
3183 if (ok) {
3184 bool prs = lib_fast::GetPmapBit(pmap,1);
3185 if (prs) {
3186 ok = lib_fast::DecodeSigned(from,parent.Value49,false);
3187 if (!ok) {
3188 state.error << "fasttest.I32Copy.Value49: bad Signed" << eol;
3189 }
3190 } else if (Value49_AssignedQ(state)) {
3191 parent.Value49 = state.Value49;
3192 } else {
3193 parent.Value49 = 49;
3194 }
3195 Value49_SetAssigned(state);
3196 state.Value49 = parent.Value49;
3197 }
3198 return ok;
3199}
3200
3201// --- fasttest.I32Copy..FixEncode
3202void fasttest::I32Copy_FixEncode(cstring& buf, fasttest::I32Copy& parent, char soh) {
3203 buf << "1=" << parent.Value49 << soh;
3204}
3205
3206// --- fasttest.I32CopyNull.base.CopyOut
3207// Copy fields out of row
3208void fasttest::parent_CopyOut(fasttest::I32CopyNull &row, fasttest::TemplateHeader &out) {
3209 // length: field value is computed
3210 // id: field value is computed
3211 (void)row;//only to avoid -Wunused-parameter
3212 (void)out;//only to avoid -Wunused-parameter
3213}
3214
3215// --- fasttest.I32CopyNull.Value51.ReadStrptrMaybe
3216inline static bool fasttest::Value51_ReadStrptrMaybe(fasttest::I32CopyNull &parent, algo::strptr in_str) {
3217 bool retval = true;
3218 i32 Value51_tmp;
3219 retval = i32_ReadStrptrMaybe(Value51_tmp, in_str);
3220 if (retval) {
3221 Value51_Set(parent, Value51_tmp);
3222 }
3223 return retval;
3224}
3225
3226// --- fasttest.I32CopyNull.pmask_bitcurs.Next
3227// proceed to next item
3228void fasttest::I32CopyNull_pmask_bitcurs_Next(I32CopyNull_pmask_bitcurs &curs) {
3229 ++curs.bit;
3230 int index = curs.bit / 32;
3231 int offset = curs.bit % 32;
3232 for (; index < curs.n_elems; ++index, offset = 0) {
3233 u64 rest = curs.elems[index] >> offset;
3234 if (rest) {
3235 offset += algo::u64_BitScanForward(rest);
3236 break;
3237 }
3238 }
3239 curs.bit = index * 32 + offset;
3240}
3241
3242// --- fasttest.I32CopyNull..ReadFieldMaybe
3243bool fasttest::I32CopyNull_ReadFieldMaybe(fasttest::I32CopyNull& parent, algo::strptr field, algo::strptr strval) {
3244 bool retval = true;
3245 fasttest::FieldId field_id;
3246 (void)value_SetStrptrMaybe(field_id,field);
3247 switch(field_id) {
3248 case fasttest_FieldId_base: {
3249 retval = false;
3250 break;
3251 }
3252 case fasttest_FieldId_length: {
3253 retval = false;
3254 break;
3255 }
3256 case fasttest_FieldId_id: {
3257 retval = false;
3258 break;
3259 }
3260 case fasttest_FieldId_pmask: {
3261 retval = false;
3262 break;
3263 }
3264 case fasttest_FieldId_Value51: {
3265 retval = Value51_ReadStrptrMaybe(parent, strval);
3266 if (retval) {
3267 pmask_qSetBit(parent, 0);
3268 }
3269 break;
3270 }
3271 default: break;
3272 }
3273 if (!retval) {
3274 algo_lib::AppendErrtext("attr",field);
3275 }
3276 return retval;
3277}
3278
3279// --- fasttest.I32CopyNull..ReadStrptrMaybe
3280// Read fields of fasttest::I32CopyNull from an ascii string.
3281// The format of the string is an ssim Tuple
3282bool fasttest::I32CopyNull_ReadStrptrMaybe(fasttest::I32CopyNull &parent, algo::strptr in_str) {
3283 bool retval = true;
3284 retval = algo::StripTypeTag(in_str, "fasttest.I32CopyNull");
3285 ind_beg(algo::Attr_curs, attr, in_str) {
3286 retval = retval && I32CopyNull_ReadFieldMaybe(parent, attr.name, attr.value);
3287 }ind_end;
3288 return retval;
3289}
3290
3291// --- fasttest.I32CopyNull..Print
3292// print string representation of ROW to string STR
3293// cfmt:fasttest.I32CopyNull.String printfmt:Tuple
3294void fasttest::I32CopyNull_Print(fasttest::I32CopyNull& row, algo::cstring& str) {
3295 algo::tempstr temp;
3296 str << "fasttest.I32CopyNull";
3297
3298 if (Value51_PresentQ(row)) {
3299 i32_Print(row.Value51, temp);
3300 PrintAttrSpaceReset(str,"Value51", temp);
3301 }
3302}
3303
3304// --- fasttest.I32CopyNull..FastEncode
3305void fasttest::I32CopyNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32CopyNull& parent) {
3306 int index = ary_N(buf);
3307 u64 pmap(0);
3308 if (!tid_AssignedQ(state) || parent.id != state.tid) {
3309 lib_fast::EncodeUnsigned(buf,parent.id,false);
3310 lib_fast::SetPmapBit(pmap,0);
3311 }
3312 tid_SetAssigned(state);
3313 state.tid = parent.id;
3314 // Value51 signed copy optional
3315 if (Value51_PresentQ(parent)) {
3316 if (!Value51_AssignedQ(state) || !Value51_PresentQ(state) || parent.Value51 != state.Value51 ) {
3317 lib_fast::EncodeSigned(buf,parent.Value51,true);
3318 lib_fast::SetPmapBit(pmap,1);
3319 }
3320 } else {
3321 if (Value51_AssignedQ(state)) {
3322 lib_fast::EncodeNull(buf);
3323 lib_fast::SetPmapBit(pmap,1);
3324 }
3325 }
3326 state.Value51 = parent.Value51;
3327 present_qSetBitVal(state,Value51_Present_GetBit(state),Value51_PresentQ(parent));
3328 Value51_SetAssigned(state);
3329 lib_fast::InsertPmap(buf,index,pmap);
3330}
3331
3332// --- fasttest.I32CopyNull..FastDecode
3333bool fasttest::I32CopyNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32CopyNull& parent) {
3334 bool ok = true;
3335 // Value51 signed copy optional
3336 if (ok) {
3337 bool prs = lib_fast::GetPmapBit(pmap,1);
3338 if (prs) {
3339 prs = !lib_fast::DecodeNull(from);
3340 if (prs) {
3341 ok = lib_fast::DecodeSigned(from,parent.Value51,true);
3342 if (!ok) {
3343 state.error << "fasttest.I32CopyNull.Value51: bad Signed" << eol;
3344 }
3345 }
3346 } else if (Value51_AssignedQ(state)) {
3347 parent.Value51 = state.Value51;
3348 prs = Value51_PresentQ(state);
3349 } else {
3350 prs = false;
3351 }
3352 pmask_qSetBitVal(parent,Value51_Present_GetBit(parent),prs);
3353 Value51_SetAssigned(state);
3354 present_qSetBitVal(state,Value51_Present_GetBit(state),prs);
3355 state.Value51 = parent.Value51;
3356 }
3357 return ok;
3358}
3359
3360// --- fasttest.I32CopyNull..FixEncode
3361void fasttest::I32CopyNull_FixEncode(cstring& buf, fasttest::I32CopyNull& parent, char soh) {
3362 if (Value51_PresentQ(parent)) {
3363 buf << "1=" << parent.Value51 << soh;
3364 }
3365}
3366
3367// --- fasttest.I32CopyOpt.base.CopyOut
3368// Copy fields out of row
3369void fasttest::parent_CopyOut(fasttest::I32CopyOpt &row, fasttest::TemplateHeader &out) {
3370 // length: field value is computed
3371 // id: field value is computed
3372 (void)row;//only to avoid -Wunused-parameter
3373 (void)out;//only to avoid -Wunused-parameter
3374}
3375
3376// --- fasttest.I32CopyOpt.Value50.ReadStrptrMaybe
3377inline static bool fasttest::Value50_ReadStrptrMaybe(fasttest::I32CopyOpt &parent, algo::strptr in_str) {
3378 bool retval = true;
3379 i32 Value50_tmp;
3380 retval = i32_ReadStrptrMaybe(Value50_tmp, in_str);
3381 if (retval) {
3382 Value50_Set(parent, Value50_tmp);
3383 }
3384 return retval;
3385}
3386
3387// --- fasttest.I32CopyOpt.pmask_bitcurs.Next
3388// proceed to next item
3389void fasttest::I32CopyOpt_pmask_bitcurs_Next(I32CopyOpt_pmask_bitcurs &curs) {
3390 ++curs.bit;
3391 int index = curs.bit / 32;
3392 int offset = curs.bit % 32;
3393 for (; index < curs.n_elems; ++index, offset = 0) {
3394 u64 rest = curs.elems[index] >> offset;
3395 if (rest) {
3396 offset += algo::u64_BitScanForward(rest);
3397 break;
3398 }
3399 }
3400 curs.bit = index * 32 + offset;
3401}
3402
3403// --- fasttest.I32CopyOpt..ReadFieldMaybe
3404bool fasttest::I32CopyOpt_ReadFieldMaybe(fasttest::I32CopyOpt& parent, algo::strptr field, algo::strptr strval) {
3405 bool retval = true;
3406 fasttest::FieldId field_id;
3407 (void)value_SetStrptrMaybe(field_id,field);
3408 switch(field_id) {
3409 case fasttest_FieldId_base: {
3410 retval = false;
3411 break;
3412 }
3413 case fasttest_FieldId_length: {
3414 retval = false;
3415 break;
3416 }
3417 case fasttest_FieldId_id: {
3418 retval = false;
3419 break;
3420 }
3421 case fasttest_FieldId_pmask: {
3422 retval = false;
3423 break;
3424 }
3425 case fasttest_FieldId_Value50: {
3426 retval = Value50_ReadStrptrMaybe(parent, strval);
3427 if (retval) {
3428 pmask_qSetBit(parent, 0);
3429 }
3430 break;
3431 }
3432 default: break;
3433 }
3434 if (!retval) {
3435 algo_lib::AppendErrtext("attr",field);
3436 }
3437 return retval;
3438}
3439
3440// --- fasttest.I32CopyOpt..ReadStrptrMaybe
3441// Read fields of fasttest::I32CopyOpt from an ascii string.
3442// The format of the string is an ssim Tuple
3443bool fasttest::I32CopyOpt_ReadStrptrMaybe(fasttest::I32CopyOpt &parent, algo::strptr in_str) {
3444 bool retval = true;
3445 retval = algo::StripTypeTag(in_str, "fasttest.I32CopyOpt");
3446 ind_beg(algo::Attr_curs, attr, in_str) {
3447 retval = retval && I32CopyOpt_ReadFieldMaybe(parent, attr.name, attr.value);
3448 }ind_end;
3449 return retval;
3450}
3451
3452// --- fasttest.I32CopyOpt..Print
3453// print string representation of ROW to string STR
3454// cfmt:fasttest.I32CopyOpt.String printfmt:Tuple
3455void fasttest::I32CopyOpt_Print(fasttest::I32CopyOpt& row, algo::cstring& str) {
3456 algo::tempstr temp;
3457 str << "fasttest.I32CopyOpt";
3458
3459 if (Value50_PresentQ(row)) {
3460 i32_Print(row.Value50, temp);
3461 PrintAttrSpaceReset(str,"Value50", temp);
3462 }
3463}
3464
3465// --- fasttest.I32CopyOpt..FastEncode
3466void fasttest::I32CopyOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32CopyOpt& parent) {
3467 int index = ary_N(buf);
3468 u64 pmap(0);
3469 if (!tid_AssignedQ(state) || parent.id != state.tid) {
3470 lib_fast::EncodeUnsigned(buf,parent.id,false);
3471 lib_fast::SetPmapBit(pmap,0);
3472 }
3473 tid_SetAssigned(state);
3474 state.tid = parent.id;
3475 // Value50 signed copy optional
3476 if (Value50_PresentQ(parent)) {
3477 if (Value50_AssignedQ(state) ? !Value50_PresentQ(state) || parent.Value50 != state.Value50 : parent.Value50 != 50) {
3478 lib_fast::EncodeSigned(buf,parent.Value50,true);
3479 lib_fast::SetPmapBit(pmap,1);
3480 }
3481 } else {
3482 if (Value50_AssignedQ(state) && Value50_PresentQ(state)) {
3483 lib_fast::EncodeNull(buf);
3484 lib_fast::SetPmapBit(pmap,1);
3485 }
3486 }
3487 state.Value50 = parent.Value50;
3488 present_qSetBitVal(state,Value50_Present_GetBit(state),Value50_PresentQ(parent));
3489 Value50_SetAssigned(state);
3490 lib_fast::InsertPmap(buf,index,pmap);
3491}
3492
3493// --- fasttest.I32CopyOpt..FastDecode
3494bool fasttest::I32CopyOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32CopyOpt& parent) {
3495 bool ok = true;
3496 // Value50 signed copy optional
3497 if (ok) {
3498 bool prs = lib_fast::GetPmapBit(pmap,1);
3499 if (prs) {
3500 prs = !lib_fast::DecodeNull(from);
3501 if (prs) {
3502 ok = lib_fast::DecodeSigned(from,parent.Value50,true);
3503 if (!ok) {
3504 state.error << "fasttest.I32CopyOpt.Value50: bad Signed" << eol;
3505 }
3506 }
3507 } else if (Value50_AssignedQ(state)) {
3508 parent.Value50 = state.Value50;
3509 prs = Value50_PresentQ(state);
3510 } else {
3511 parent.Value50 = 50;
3512 prs = true;
3513 }
3514 pmask_qSetBitVal(parent,Value50_Present_GetBit(parent),prs);
3515 Value50_SetAssigned(state);
3516 present_qSetBitVal(state,Value50_Present_GetBit(state),prs);
3517 state.Value50 = parent.Value50;
3518 }
3519 return ok;
3520}
3521
3522// --- fasttest.I32CopyOpt..FixEncode
3523void fasttest::I32CopyOpt_FixEncode(cstring& buf, fasttest::I32CopyOpt& parent, char soh) {
3524 if (Value50_PresentQ(parent)) {
3525 buf << "1=" << parent.Value50 << soh;
3526 }
3527}
3528
3529// --- fasttest.I32Delta.base.CopyOut
3530// Copy fields out of row
3531void fasttest::parent_CopyOut(fasttest::I32Delta &row, fasttest::TemplateHeader &out) {
3532 // length: field value is computed
3533 // id: field value is computed
3534 (void)row;//only to avoid -Wunused-parameter
3535 (void)out;//only to avoid -Wunused-parameter
3536}
3537
3538// --- fasttest.I32Delta..ReadFieldMaybe
3539bool fasttest::I32Delta_ReadFieldMaybe(fasttest::I32Delta& parent, algo::strptr field, algo::strptr strval) {
3540 bool retval = true;
3541 fasttest::FieldId field_id;
3542 (void)value_SetStrptrMaybe(field_id,field);
3543 switch(field_id) {
3544 case fasttest_FieldId_base: {
3545 retval = false;
3546 break;
3547 }
3548 case fasttest_FieldId_length: {
3549 retval = false;
3550 break;
3551 }
3552 case fasttest_FieldId_id: {
3553 retval = false;
3554 break;
3555 }
3556 case fasttest_FieldId_Value65: {
3557 retval = i32_ReadStrptrMaybe(parent.Value65, strval);
3558 break;
3559 }
3560 default: break;
3561 }
3562 if (!retval) {
3563 algo_lib::AppendErrtext("attr",field);
3564 }
3565 return retval;
3566}
3567
3568// --- fasttest.I32Delta..ReadStrptrMaybe
3569// Read fields of fasttest::I32Delta from an ascii string.
3570// The format of the string is an ssim Tuple
3571bool fasttest::I32Delta_ReadStrptrMaybe(fasttest::I32Delta &parent, algo::strptr in_str) {
3572 bool retval = true;
3573 retval = algo::StripTypeTag(in_str, "fasttest.I32Delta");
3574 ind_beg(algo::Attr_curs, attr, in_str) {
3575 retval = retval && I32Delta_ReadFieldMaybe(parent, attr.name, attr.value);
3576 }ind_end;
3577 return retval;
3578}
3579
3580// --- fasttest.I32Delta..Print
3581// print string representation of ROW to string STR
3582// cfmt:fasttest.I32Delta.String printfmt:Tuple
3583void fasttest::I32Delta_Print(fasttest::I32Delta& row, algo::cstring& str) {
3584 algo::tempstr temp;
3585 str << "fasttest.I32Delta";
3586
3587 i32_Print(row.Value65, temp);
3588 PrintAttrSpaceReset(str,"Value65", temp);
3589}
3590
3591// --- fasttest.I32Delta..FastEncode
3592void fasttest::I32Delta_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32Delta& parent) {
3593 int index = ary_N(buf);
3594 u64 pmap(0);
3595 if (!tid_AssignedQ(state) || parent.id != state.tid) {
3596 lib_fast::EncodeUnsigned(buf,parent.id,false);
3597 lib_fast::SetPmapBit(pmap,0);
3598 }
3599 tid_SetAssigned(state);
3600 state.tid = parent.id;
3601 // Value65 signed delta mandatory
3602 if (!Value65_AssignedQ(state)) {
3603 Value65_SetAssigned(state);
3604 state.Value65 = 65;
3605 }
3606 lib_fast::EncodeDeltaSigned(buf,state.Value65,parent.Value65,false);
3607 state.Value65 = parent.Value65;
3608 lib_fast::InsertPmap(buf,index,pmap);
3609}
3610
3611// --- fasttest.I32Delta..FastDecode
3612bool fasttest::I32Delta_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32Delta& parent) {
3613 bool ok = true;
3614 // Value65 signed delta mandatory
3615 if (ok) {
3616 if (!Value65_AssignedQ(state)) {
3617 Value65_SetAssigned(state);
3618 state.Value65 = 65;
3619 }
3620 ok = lib_fast::DecodeDeltaSigned(from,state.Value65,parent.Value65,false);
3621 if (!ok) {
3622 state.error << "fasttest.I32Delta.Value65: bad Signed delta" << eol;
3623 }
3624 state.Value65 = parent.Value65;
3625 }
3626 (void)pmap;//only to avoid -Wunused-parameter
3627 return ok;
3628}
3629
3630// --- fasttest.I32Delta..FixEncode
3631void fasttest::I32Delta_FixEncode(cstring& buf, fasttest::I32Delta& parent, char soh) {
3632 buf << "1=" << parent.Value65 << soh;
3633}
3634
3635// --- fasttest.I32DeltaImpl.base.CopyOut
3636// Copy fields out of row
3637void fasttest::parent_CopyOut(fasttest::I32DeltaImpl &row, fasttest::TemplateHeader &out) {
3638 // length: field value is computed
3639 // id: field value is computed
3640 (void)row;//only to avoid -Wunused-parameter
3641 (void)out;//only to avoid -Wunused-parameter
3642}
3643
3644// --- fasttest.I32DeltaImpl..ReadFieldMaybe
3645bool fasttest::I32DeltaImpl_ReadFieldMaybe(fasttest::I32DeltaImpl& parent, algo::strptr field, algo::strptr strval) {
3646 bool retval = true;
3647 fasttest::FieldId field_id;
3648 (void)value_SetStrptrMaybe(field_id,field);
3649 switch(field_id) {
3650 case fasttest_FieldId_base: {
3651 retval = false;
3652 break;
3653 }
3654 case fasttest_FieldId_length: {
3655 retval = false;
3656 break;
3657 }
3658 case fasttest_FieldId_id: {
3659 retval = false;
3660 break;
3661 }
3662 case fasttest_FieldId_Value66: {
3663 retval = i32_ReadStrptrMaybe(parent.Value66, strval);
3664 break;
3665 }
3666 default: break;
3667 }
3668 if (!retval) {
3669 algo_lib::AppendErrtext("attr",field);
3670 }
3671 return retval;
3672}
3673
3674// --- fasttest.I32DeltaImpl..ReadStrptrMaybe
3675// Read fields of fasttest::I32DeltaImpl from an ascii string.
3676// The format of the string is an ssim Tuple
3677bool fasttest::I32DeltaImpl_ReadStrptrMaybe(fasttest::I32DeltaImpl &parent, algo::strptr in_str) {
3678 bool retval = true;
3679 retval = algo::StripTypeTag(in_str, "fasttest.I32DeltaImpl");
3680 ind_beg(algo::Attr_curs, attr, in_str) {
3681 retval = retval && I32DeltaImpl_ReadFieldMaybe(parent, attr.name, attr.value);
3682 }ind_end;
3683 return retval;
3684}
3685
3686// --- fasttest.I32DeltaImpl..Print
3687// print string representation of ROW to string STR
3688// cfmt:fasttest.I32DeltaImpl.String printfmt:Tuple
3689void fasttest::I32DeltaImpl_Print(fasttest::I32DeltaImpl& row, algo::cstring& str) {
3690 algo::tempstr temp;
3691 str << "fasttest.I32DeltaImpl";
3692
3693 i32_Print(row.Value66, temp);
3694 PrintAttrSpaceReset(str,"Value66", temp);
3695}
3696
3697// --- fasttest.I32DeltaImpl..FastEncode
3698void fasttest::I32DeltaImpl_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32DeltaImpl& parent) {
3699 int index = ary_N(buf);
3700 u64 pmap(0);
3701 if (!tid_AssignedQ(state) || parent.id != state.tid) {
3702 lib_fast::EncodeUnsigned(buf,parent.id,false);
3703 lib_fast::SetPmapBit(pmap,0);
3704 }
3705 tid_SetAssigned(state);
3706 state.tid = parent.id;
3707 // Value66 signed delta mandatory
3708 if (!Value66_AssignedQ(state)) {
3709 Value66_SetAssigned(state);
3710 state.Value66 = 0;
3711 }
3712 lib_fast::EncodeDeltaSigned(buf,state.Value66,parent.Value66,false);
3713 state.Value66 = parent.Value66;
3714 lib_fast::InsertPmap(buf,index,pmap);
3715}
3716
3717// --- fasttest.I32DeltaImpl..FastDecode
3718bool fasttest::I32DeltaImpl_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32DeltaImpl& parent) {
3719 bool ok = true;
3720 // Value66 signed delta mandatory
3721 if (ok) {
3722 if (!Value66_AssignedQ(state)) {
3723 Value66_SetAssigned(state);
3724 state.Value66 = 0;
3725 }
3726 ok = lib_fast::DecodeDeltaSigned(from,state.Value66,parent.Value66,false);
3727 if (!ok) {
3728 state.error << "fasttest.I32DeltaImpl.Value66: bad Signed delta" << eol;
3729 }
3730 state.Value66 = parent.Value66;
3731 }
3732 (void)pmap;//only to avoid -Wunused-parameter
3733 return ok;
3734}
3735
3736// --- fasttest.I32DeltaImpl..FixEncode
3737void fasttest::I32DeltaImpl_FixEncode(cstring& buf, fasttest::I32DeltaImpl& parent, char soh) {
3738 buf << "1=" << parent.Value66 << soh;
3739}
3740
3741// --- fasttest.I32DeltaNull.base.CopyOut
3742// Copy fields out of row
3743void fasttest::parent_CopyOut(fasttest::I32DeltaNull &row, fasttest::TemplateHeader &out) {
3744 // length: field value is computed
3745 // id: field value is computed
3746 (void)row;//only to avoid -Wunused-parameter
3747 (void)out;//only to avoid -Wunused-parameter
3748}
3749
3750// --- fasttest.I32DeltaNull.Value68.ReadStrptrMaybe
3751inline static bool fasttest::Value68_ReadStrptrMaybe(fasttest::I32DeltaNull &parent, algo::strptr in_str) {
3752 bool retval = true;
3753 i32 Value68_tmp;
3754 retval = i32_ReadStrptrMaybe(Value68_tmp, in_str);
3755 if (retval) {
3756 Value68_Set(parent, Value68_tmp);
3757 }
3758 return retval;
3759}
3760
3761// --- fasttest.I32DeltaNull.pmask_bitcurs.Next
3762// proceed to next item
3763void fasttest::I32DeltaNull_pmask_bitcurs_Next(I32DeltaNull_pmask_bitcurs &curs) {
3764 ++curs.bit;
3765 int index = curs.bit / 32;
3766 int offset = curs.bit % 32;
3767 for (; index < curs.n_elems; ++index, offset = 0) {
3768 u64 rest = curs.elems[index] >> offset;
3769 if (rest) {
3770 offset += algo::u64_BitScanForward(rest);
3771 break;
3772 }
3773 }
3774 curs.bit = index * 32 + offset;
3775}
3776
3777// --- fasttest.I32DeltaNull..ReadFieldMaybe
3778bool fasttest::I32DeltaNull_ReadFieldMaybe(fasttest::I32DeltaNull& parent, algo::strptr field, algo::strptr strval) {
3779 bool retval = true;
3780 fasttest::FieldId field_id;
3781 (void)value_SetStrptrMaybe(field_id,field);
3782 switch(field_id) {
3783 case fasttest_FieldId_base: {
3784 retval = false;
3785 break;
3786 }
3787 case fasttest_FieldId_length: {
3788 retval = false;
3789 break;
3790 }
3791 case fasttest_FieldId_id: {
3792 retval = false;
3793 break;
3794 }
3795 case fasttest_FieldId_pmask: {
3796 retval = false;
3797 break;
3798 }
3799 case fasttest_FieldId_Value68: {
3800 retval = Value68_ReadStrptrMaybe(parent, strval);
3801 if (retval) {
3802 pmask_qSetBit(parent, 0);
3803 }
3804 break;
3805 }
3806 default: break;
3807 }
3808 if (!retval) {
3809 algo_lib::AppendErrtext("attr",field);
3810 }
3811 return retval;
3812}
3813
3814// --- fasttest.I32DeltaNull..ReadStrptrMaybe
3815// Read fields of fasttest::I32DeltaNull from an ascii string.
3816// The format of the string is an ssim Tuple
3817bool fasttest::I32DeltaNull_ReadStrptrMaybe(fasttest::I32DeltaNull &parent, algo::strptr in_str) {
3818 bool retval = true;
3819 retval = algo::StripTypeTag(in_str, "fasttest.I32DeltaNull");
3820 ind_beg(algo::Attr_curs, attr, in_str) {
3821 retval = retval && I32DeltaNull_ReadFieldMaybe(parent, attr.name, attr.value);
3822 }ind_end;
3823 return retval;
3824}
3825
3826// --- fasttest.I32DeltaNull..Print
3827// print string representation of ROW to string STR
3828// cfmt:fasttest.I32DeltaNull.String printfmt:Tuple
3829void fasttest::I32DeltaNull_Print(fasttest::I32DeltaNull& row, algo::cstring& str) {
3830 algo::tempstr temp;
3831 str << "fasttest.I32DeltaNull";
3832
3833 if (Value68_PresentQ(row)) {
3834 i32_Print(row.Value68, temp);
3835 PrintAttrSpaceReset(str,"Value68", temp);
3836 }
3837}
3838
3839// --- fasttest.I32DeltaNull..FastEncode
3840void fasttest::I32DeltaNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32DeltaNull& parent) {
3841 int index = ary_N(buf);
3842 u64 pmap(0);
3843 if (!tid_AssignedQ(state) || parent.id != state.tid) {
3844 lib_fast::EncodeUnsigned(buf,parent.id,false);
3845 lib_fast::SetPmapBit(pmap,0);
3846 }
3847 tid_SetAssigned(state);
3848 state.tid = parent.id;
3849 // Value68 signed delta optional
3850 if (!Value68_AssignedQ(state)) {
3851 Value68_SetAssigned(state);
3852 present_qSetBitVal(state,Value68_Present_GetBit(state),Value68_PresentQ(parent));
3853 state.Value68 = 0;
3854 }
3855 if (Value68_PresentQ(parent)) {
3856 if (!Value68_PresentQ(state)) {
3857 state.Value68 = 0;
3858 }
3859 lib_fast::EncodeDeltaSigned(buf,state.Value68,parent.Value68,true);
3860 } else {
3861 lib_fast::EncodeNull(buf);
3862 }
3863 state.Value68 = parent.Value68;
3864 present_qSetBitVal(state,Value68_Present_GetBit(state),Value68_PresentQ(parent));
3865 lib_fast::InsertPmap(buf,index,pmap);
3866}
3867
3868// --- fasttest.I32DeltaNull..FastDecode
3869bool fasttest::I32DeltaNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32DeltaNull& parent) {
3870 bool ok = true;
3871 // Value68 signed delta optional
3872 if (ok) {
3873 if (!Value68_AssignedQ(state)) {
3874 Value68_SetAssigned(state);
3875 bool prs(true);
3876 present_qSetBitVal(state,Value68_Present_GetBit(state),prs);
3877 state.Value68 = 0;
3878 }
3879 bool prs = !lib_fast::DecodeNull(from);
3880 if (prs) {
3881 if (!Value68_PresentQ(state)) {
3882 state.Value68 = 0;
3883 }
3884 ok = lib_fast::DecodeDeltaSigned(from,state.Value68,parent.Value68,true);
3885 if (!ok) {
3886 state.error << "fasttest.I32DeltaNull.Value68: bad Signed delta" << eol;
3887 }
3888 state.Value68 = parent.Value68;
3889 }
3890 pmask_qSetBitVal(parent,Value68_Present_GetBit(parent),prs);
3891 present_qSetBitVal(state,Value68_Present_GetBit(state),prs);
3892 }
3893 (void)pmap;//only to avoid -Wunused-parameter
3894 return ok;
3895}
3896
3897// --- fasttest.I32DeltaNull..FixEncode
3898void fasttest::I32DeltaNull_FixEncode(cstring& buf, fasttest::I32DeltaNull& parent, char soh) {
3899 if (Value68_PresentQ(parent)) {
3900 buf << "1=" << parent.Value68 << soh;
3901 }
3902}
3903
3904// --- fasttest.I32DeltaOpt.base.CopyOut
3905// Copy fields out of row
3906void fasttest::parent_CopyOut(fasttest::I32DeltaOpt &row, fasttest::TemplateHeader &out) {
3907 // length: field value is computed
3908 // id: field value is computed
3909 (void)row;//only to avoid -Wunused-parameter
3910 (void)out;//only to avoid -Wunused-parameter
3911}
3912
3913// --- fasttest.I32DeltaOpt.Value67.ReadStrptrMaybe
3914inline static bool fasttest::Value67_ReadStrptrMaybe(fasttest::I32DeltaOpt &parent, algo::strptr in_str) {
3915 bool retval = true;
3916 i32 Value67_tmp;
3917 retval = i32_ReadStrptrMaybe(Value67_tmp, in_str);
3918 if (retval) {
3919 Value67_Set(parent, Value67_tmp);
3920 }
3921 return retval;
3922}
3923
3924// --- fasttest.I32DeltaOpt.pmask_bitcurs.Next
3925// proceed to next item
3926void fasttest::I32DeltaOpt_pmask_bitcurs_Next(I32DeltaOpt_pmask_bitcurs &curs) {
3927 ++curs.bit;
3928 int index = curs.bit / 32;
3929 int offset = curs.bit % 32;
3930 for (; index < curs.n_elems; ++index, offset = 0) {
3931 u64 rest = curs.elems[index] >> offset;
3932 if (rest) {
3933 offset += algo::u64_BitScanForward(rest);
3934 break;
3935 }
3936 }
3937 curs.bit = index * 32 + offset;
3938}
3939
3940// --- fasttest.I32DeltaOpt..ReadFieldMaybe
3941bool fasttest::I32DeltaOpt_ReadFieldMaybe(fasttest::I32DeltaOpt& parent, algo::strptr field, algo::strptr strval) {
3942 bool retval = true;
3943 fasttest::FieldId field_id;
3944 (void)value_SetStrptrMaybe(field_id,field);
3945 switch(field_id) {
3946 case fasttest_FieldId_base: {
3947 retval = false;
3948 break;
3949 }
3950 case fasttest_FieldId_length: {
3951 retval = false;
3952 break;
3953 }
3954 case fasttest_FieldId_id: {
3955 retval = false;
3956 break;
3957 }
3958 case fasttest_FieldId_pmask: {
3959 retval = false;
3960 break;
3961 }
3962 case fasttest_FieldId_Value67: {
3963 retval = Value67_ReadStrptrMaybe(parent, strval);
3964 if (retval) {
3965 pmask_qSetBit(parent, 0);
3966 }
3967 break;
3968 }
3969 default: break;
3970 }
3971 if (!retval) {
3972 algo_lib::AppendErrtext("attr",field);
3973 }
3974 return retval;
3975}
3976
3977// --- fasttest.I32DeltaOpt..ReadStrptrMaybe
3978// Read fields of fasttest::I32DeltaOpt from an ascii string.
3979// The format of the string is an ssim Tuple
3980bool fasttest::I32DeltaOpt_ReadStrptrMaybe(fasttest::I32DeltaOpt &parent, algo::strptr in_str) {
3981 bool retval = true;
3982 retval = algo::StripTypeTag(in_str, "fasttest.I32DeltaOpt");
3983 ind_beg(algo::Attr_curs, attr, in_str) {
3984 retval = retval && I32DeltaOpt_ReadFieldMaybe(parent, attr.name, attr.value);
3985 }ind_end;
3986 return retval;
3987}
3988
3989// --- fasttest.I32DeltaOpt..Print
3990// print string representation of ROW to string STR
3991// cfmt:fasttest.I32DeltaOpt.String printfmt:Tuple
3992void fasttest::I32DeltaOpt_Print(fasttest::I32DeltaOpt& row, algo::cstring& str) {
3993 algo::tempstr temp;
3994 str << "fasttest.I32DeltaOpt";
3995
3996 if (Value67_PresentQ(row)) {
3997 i32_Print(row.Value67, temp);
3998 PrintAttrSpaceReset(str,"Value67", temp);
3999 }
4000}
4001
4002// --- fasttest.I32DeltaOpt..FastEncode
4003void fasttest::I32DeltaOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32DeltaOpt& parent) {
4004 int index = ary_N(buf);
4005 u64 pmap(0);
4006 if (!tid_AssignedQ(state) || parent.id != state.tid) {
4007 lib_fast::EncodeUnsigned(buf,parent.id,false);
4008 lib_fast::SetPmapBit(pmap,0);
4009 }
4010 tid_SetAssigned(state);
4011 state.tid = parent.id;
4012 // Value67 signed delta optional
4013 if (!Value67_AssignedQ(state)) {
4014 Value67_SetAssigned(state);
4015 present_qSetBitVal(state,Value67_Present_GetBit(state),Value67_PresentQ(parent));
4016 state.Value67 = 67;
4017 }
4018 if (Value67_PresentQ(parent)) {
4019 if (!Value67_PresentQ(state)) {
4020 state.Value67 = 67;
4021 }
4022 lib_fast::EncodeDeltaSigned(buf,state.Value67,parent.Value67,true);
4023 } else {
4024 lib_fast::EncodeNull(buf);
4025 }
4026 state.Value67 = parent.Value67;
4027 present_qSetBitVal(state,Value67_Present_GetBit(state),Value67_PresentQ(parent));
4028 lib_fast::InsertPmap(buf,index,pmap);
4029}
4030
4031// --- fasttest.I32DeltaOpt..FastDecode
4032bool fasttest::I32DeltaOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32DeltaOpt& parent) {
4033 bool ok = true;
4034 // Value67 signed delta optional
4035 if (ok) {
4036 if (!Value67_AssignedQ(state)) {
4037 Value67_SetAssigned(state);
4038 bool prs(true);
4039 present_qSetBitVal(state,Value67_Present_GetBit(state),prs);
4040 state.Value67 = 67;
4041 }
4042 bool prs = !lib_fast::DecodeNull(from);
4043 if (prs) {
4044 if (!Value67_PresentQ(state)) {
4045 state.Value67 = 67;
4046 }
4047 ok = lib_fast::DecodeDeltaSigned(from,state.Value67,parent.Value67,true);
4048 if (!ok) {
4049 state.error << "fasttest.I32DeltaOpt.Value67: bad Signed delta" << eol;
4050 }
4051 state.Value67 = parent.Value67;
4052 }
4053 pmask_qSetBitVal(parent,Value67_Present_GetBit(parent),prs);
4054 present_qSetBitVal(state,Value67_Present_GetBit(state),prs);
4055 }
4056 (void)pmap;//only to avoid -Wunused-parameter
4057 return ok;
4058}
4059
4060// --- fasttest.I32DeltaOpt..FixEncode
4061void fasttest::I32DeltaOpt_FixEncode(cstring& buf, fasttest::I32DeltaOpt& parent, char soh) {
4062 if (Value67_PresentQ(parent)) {
4063 buf << "1=" << parent.Value67 << soh;
4064 }
4065}
4066
4067// --- fasttest.I32Dflt.base.CopyOut
4068// Copy fields out of row
4069void fasttest::parent_CopyOut(fasttest::I32Dflt &row, fasttest::TemplateHeader &out) {
4070 // length: field value is computed
4071 // id: field value is computed
4072 (void)row;//only to avoid -Wunused-parameter
4073 (void)out;//only to avoid -Wunused-parameter
4074}
4075
4076// --- fasttest.I32Dflt..ReadFieldMaybe
4077bool fasttest::I32Dflt_ReadFieldMaybe(fasttest::I32Dflt& parent, algo::strptr field, algo::strptr strval) {
4078 bool retval = true;
4079 fasttest::FieldId field_id;
4080 (void)value_SetStrptrMaybe(field_id,field);
4081 switch(field_id) {
4082 case fasttest_FieldId_base: {
4083 retval = false;
4084 break;
4085 }
4086 case fasttest_FieldId_length: {
4087 retval = false;
4088 break;
4089 }
4090 case fasttest_FieldId_id: {
4091 retval = false;
4092 break;
4093 }
4094 case fasttest_FieldId_Value: {
4095 retval = i32_ReadStrptrMaybe(parent.Value, strval);
4096 break;
4097 }
4098 default: break;
4099 }
4100 if (!retval) {
4101 algo_lib::AppendErrtext("attr",field);
4102 }
4103 return retval;
4104}
4105
4106// --- fasttest.I32Dflt..ReadStrptrMaybe
4107// Read fields of fasttest::I32Dflt from an ascii string.
4108// The format of the string is an ssim Tuple
4109bool fasttest::I32Dflt_ReadStrptrMaybe(fasttest::I32Dflt &parent, algo::strptr in_str) {
4110 bool retval = true;
4111 retval = algo::StripTypeTag(in_str, "fasttest.I32Dflt");
4112 ind_beg(algo::Attr_curs, attr, in_str) {
4113 retval = retval && I32Dflt_ReadFieldMaybe(parent, attr.name, attr.value);
4114 }ind_end;
4115 return retval;
4116}
4117
4118// --- fasttest.I32Dflt..Print
4119// print string representation of ROW to string STR
4120// cfmt:fasttest.I32Dflt.String printfmt:Tuple
4121void fasttest::I32Dflt_Print(fasttest::I32Dflt& row, algo::cstring& str) {
4122 algo::tempstr temp;
4123 str << "fasttest.I32Dflt";
4124
4125 i32_Print(row.Value, temp);
4126 PrintAttrSpaceReset(str,"Value", temp);
4127}
4128
4129// --- fasttest.I32Dflt..FastEncode
4130void fasttest::I32Dflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32Dflt& parent) {
4131 int index = ary_N(buf);
4132 u64 pmap(0);
4133 if (!tid_AssignedQ(state) || parent.id != state.tid) {
4134 lib_fast::EncodeUnsigned(buf,parent.id,false);
4135 lib_fast::SetPmapBit(pmap,0);
4136 }
4137 tid_SetAssigned(state);
4138 state.tid = parent.id;
4139 // Value signed default mandatory
4140 if (parent.Value != 33) {
4141 lib_fast::EncodeSigned(buf,parent.Value,false);
4142 lib_fast::SetPmapBit(pmap,1);
4143 }
4144 lib_fast::InsertPmap(buf,index,pmap);
4145}
4146
4147// --- fasttest.I32Dflt..FastDecode
4148bool fasttest::I32Dflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32Dflt& parent) {
4149 bool ok = true;
4150 // Value signed default mandatory
4151 if (ok) {
4152 bool prs = lib_fast::GetPmapBit(pmap,1);
4153 if (prs) {
4154 ok = lib_fast::DecodeSigned(from,parent.Value,false);
4155 if (!ok) {
4156 state.error << "fasttest.I32Dflt.Value: bad Signed" << eol;
4157 }
4158 } else {
4159 parent.Value = 33;
4160 }
4161 }
4162 return ok;
4163}
4164
4165// --- fasttest.I32Dflt..FixEncode
4166void fasttest::I32Dflt_FixEncode(cstring& buf, fasttest::I32Dflt& parent, char soh) {
4167 buf << "1=" << parent.Value << soh;
4168}
4169
4170// --- fasttest.I32DfltNull.base.CopyOut
4171// Copy fields out of row
4172void fasttest::parent_CopyOut(fasttest::I32DfltNull &row, fasttest::TemplateHeader &out) {
4173 // length: field value is computed
4174 // id: field value is computed
4175 (void)row;//only to avoid -Wunused-parameter
4176 (void)out;//only to avoid -Wunused-parameter
4177}
4178
4179// --- fasttest.I32DfltNull.Value.ReadStrptrMaybe
4180inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::I32DfltNull &parent, algo::strptr in_str) {
4181 bool retval = true;
4182 i32 Value_tmp;
4183 retval = i32_ReadStrptrMaybe(Value_tmp, in_str);
4184 if (retval) {
4185 Value_Set(parent, Value_tmp);
4186 }
4187 return retval;
4188}
4189
4190// --- fasttest.I32DfltNull.pmask_bitcurs.Next
4191// proceed to next item
4192void fasttest::I32DfltNull_pmask_bitcurs_Next(I32DfltNull_pmask_bitcurs &curs) {
4193 ++curs.bit;
4194 int index = curs.bit / 32;
4195 int offset = curs.bit % 32;
4196 for (; index < curs.n_elems; ++index, offset = 0) {
4197 u64 rest = curs.elems[index] >> offset;
4198 if (rest) {
4199 offset += algo::u64_BitScanForward(rest);
4200 break;
4201 }
4202 }
4203 curs.bit = index * 32 + offset;
4204}
4205
4206// --- fasttest.I32DfltNull..ReadFieldMaybe
4207bool fasttest::I32DfltNull_ReadFieldMaybe(fasttest::I32DfltNull& parent, algo::strptr field, algo::strptr strval) {
4208 bool retval = true;
4209 fasttest::FieldId field_id;
4210 (void)value_SetStrptrMaybe(field_id,field);
4211 switch(field_id) {
4212 case fasttest_FieldId_base: {
4213 retval = false;
4214 break;
4215 }
4216 case fasttest_FieldId_length: {
4217 retval = false;
4218 break;
4219 }
4220 case fasttest_FieldId_id: {
4221 retval = false;
4222 break;
4223 }
4224 case fasttest_FieldId_pmask: {
4225 retval = false;
4226 break;
4227 }
4228 case fasttest_FieldId_Value: {
4229 retval = Value_ReadStrptrMaybe(parent, strval);
4230 if (retval) {
4231 pmask_qSetBit(parent, 0);
4232 }
4233 break;
4234 }
4235 default: break;
4236 }
4237 if (!retval) {
4238 algo_lib::AppendErrtext("attr",field);
4239 }
4240 return retval;
4241}
4242
4243// --- fasttest.I32DfltNull..ReadStrptrMaybe
4244// Read fields of fasttest::I32DfltNull from an ascii string.
4245// The format of the string is an ssim Tuple
4246bool fasttest::I32DfltNull_ReadStrptrMaybe(fasttest::I32DfltNull &parent, algo::strptr in_str) {
4247 bool retval = true;
4248 retval = algo::StripTypeTag(in_str, "fasttest.I32DfltNull");
4249 ind_beg(algo::Attr_curs, attr, in_str) {
4250 retval = retval && I32DfltNull_ReadFieldMaybe(parent, attr.name, attr.value);
4251 }ind_end;
4252 return retval;
4253}
4254
4255// --- fasttest.I32DfltNull..Print
4256// print string representation of ROW to string STR
4257// cfmt:fasttest.I32DfltNull.String printfmt:Tuple
4258void fasttest::I32DfltNull_Print(fasttest::I32DfltNull& row, algo::cstring& str) {
4259 algo::tempstr temp;
4260 str << "fasttest.I32DfltNull";
4261
4262 if (Value_PresentQ(row)) {
4263 i32_Print(row.Value, temp);
4264 PrintAttrSpaceReset(str,"Value", temp);
4265 }
4266}
4267
4268// --- fasttest.I32DfltNull..FastEncode
4269void fasttest::I32DfltNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32DfltNull& parent) {
4270 int index = ary_N(buf);
4271 u64 pmap(0);
4272 if (!tid_AssignedQ(state) || parent.id != state.tid) {
4273 lib_fast::EncodeUnsigned(buf,parent.id,false);
4274 lib_fast::SetPmapBit(pmap,0);
4275 }
4276 tid_SetAssigned(state);
4277 state.tid = parent.id;
4278 // Value signed default optional
4279 if (Value_PresentQ(parent)) {
4280 lib_fast::EncodeSigned(buf,parent.Value,true);
4281 lib_fast::SetPmapBit(pmap,1);
4282 }
4283 lib_fast::InsertPmap(buf,index,pmap);
4284}
4285
4286// --- fasttest.I32DfltNull..FastDecode
4287bool fasttest::I32DfltNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32DfltNull& parent) {
4288 bool ok = true;
4289 // Value signed default optional
4290 if (ok) {
4291 bool prs = lib_fast::GetPmapBit(pmap,1);
4292 if (prs) {
4293 prs = !lib_fast::DecodeNull(from);
4294 if (prs) {
4295 ok = lib_fast::DecodeSigned(from,parent.Value,true);
4296 if (!ok) {
4297 state.error << "fasttest.I32DfltNull.Value: bad Signed" << eol;
4298 }
4299 }
4300 } else {
4301 }
4302 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
4303 }
4304 return ok;
4305}
4306
4307// --- fasttest.I32DfltNull..FixEncode
4308void fasttest::I32DfltNull_FixEncode(cstring& buf, fasttest::I32DfltNull& parent, char soh) {
4309 if (Value_PresentQ(parent)) {
4310 buf << "1=" << parent.Value << soh;
4311 }
4312}
4313
4314// --- fasttest.I32DfltOpt.base.CopyOut
4315// Copy fields out of row
4316void fasttest::parent_CopyOut(fasttest::I32DfltOpt &row, fasttest::TemplateHeader &out) {
4317 // length: field value is computed
4318 // id: field value is computed
4319 (void)row;//only to avoid -Wunused-parameter
4320 (void)out;//only to avoid -Wunused-parameter
4321}
4322
4323// --- fasttest.I32DfltOpt.Value.ReadStrptrMaybe
4324inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::I32DfltOpt &parent, algo::strptr in_str) {
4325 bool retval = true;
4326 i32 Value_tmp;
4327 retval = i32_ReadStrptrMaybe(Value_tmp, in_str);
4328 if (retval) {
4329 Value_Set(parent, Value_tmp);
4330 }
4331 return retval;
4332}
4333
4334// --- fasttest.I32DfltOpt.pmask_bitcurs.Next
4335// proceed to next item
4336void fasttest::I32DfltOpt_pmask_bitcurs_Next(I32DfltOpt_pmask_bitcurs &curs) {
4337 ++curs.bit;
4338 int index = curs.bit / 32;
4339 int offset = curs.bit % 32;
4340 for (; index < curs.n_elems; ++index, offset = 0) {
4341 u64 rest = curs.elems[index] >> offset;
4342 if (rest) {
4343 offset += algo::u64_BitScanForward(rest);
4344 break;
4345 }
4346 }
4347 curs.bit = index * 32 + offset;
4348}
4349
4350// --- fasttest.I32DfltOpt..ReadFieldMaybe
4351bool fasttest::I32DfltOpt_ReadFieldMaybe(fasttest::I32DfltOpt& parent, algo::strptr field, algo::strptr strval) {
4352 bool retval = true;
4353 fasttest::FieldId field_id;
4354 (void)value_SetStrptrMaybe(field_id,field);
4355 switch(field_id) {
4356 case fasttest_FieldId_base: {
4357 retval = false;
4358 break;
4359 }
4360 case fasttest_FieldId_length: {
4361 retval = false;
4362 break;
4363 }
4364 case fasttest_FieldId_id: {
4365 retval = false;
4366 break;
4367 }
4368 case fasttest_FieldId_pmask: {
4369 retval = false;
4370 break;
4371 }
4372 case fasttest_FieldId_Value: {
4373 retval = Value_ReadStrptrMaybe(parent, strval);
4374 if (retval) {
4375 pmask_qSetBit(parent, 0);
4376 }
4377 break;
4378 }
4379 default: break;
4380 }
4381 if (!retval) {
4382 algo_lib::AppendErrtext("attr",field);
4383 }
4384 return retval;
4385}
4386
4387// --- fasttest.I32DfltOpt..ReadStrptrMaybe
4388// Read fields of fasttest::I32DfltOpt from an ascii string.
4389// The format of the string is an ssim Tuple
4390bool fasttest::I32DfltOpt_ReadStrptrMaybe(fasttest::I32DfltOpt &parent, algo::strptr in_str) {
4391 bool retval = true;
4392 retval = algo::StripTypeTag(in_str, "fasttest.I32DfltOpt");
4393 ind_beg(algo::Attr_curs, attr, in_str) {
4394 retval = retval && I32DfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
4395 }ind_end;
4396 return retval;
4397}
4398
4399// --- fasttest.I32DfltOpt..Print
4400// print string representation of ROW to string STR
4401// cfmt:fasttest.I32DfltOpt.String printfmt:Tuple
4402void fasttest::I32DfltOpt_Print(fasttest::I32DfltOpt& row, algo::cstring& str) {
4403 algo::tempstr temp;
4404 str << "fasttest.I32DfltOpt";
4405
4406 if (Value_PresentQ(row)) {
4407 i32_Print(row.Value, temp);
4408 PrintAttrSpaceReset(str,"Value", temp);
4409 }
4410}
4411
4412// --- fasttest.I32DfltOpt..FastEncode
4413void fasttest::I32DfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32DfltOpt& parent) {
4414 int index = ary_N(buf);
4415 u64 pmap(0);
4416 if (!tid_AssignedQ(state) || parent.id != state.tid) {
4417 lib_fast::EncodeUnsigned(buf,parent.id,false);
4418 lib_fast::SetPmapBit(pmap,0);
4419 }
4420 tid_SetAssigned(state);
4421 state.tid = parent.id;
4422 // Value signed default optional
4423 if (Value_PresentQ(parent)) {
4424 if (parent.Value != 34) {
4425 lib_fast::EncodeSigned(buf,parent.Value,true);
4426 lib_fast::SetPmapBit(pmap,1);
4427 }
4428 } else {
4429 lib_fast::EncodeNull(buf);
4430 lib_fast::SetPmapBit(pmap,1);
4431 }
4432 lib_fast::InsertPmap(buf,index,pmap);
4433}
4434
4435// --- fasttest.I32DfltOpt..FastDecode
4436bool fasttest::I32DfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32DfltOpt& parent) {
4437 bool ok = true;
4438 // Value signed default optional
4439 if (ok) {
4440 bool prs = lib_fast::GetPmapBit(pmap,1);
4441 if (prs) {
4442 prs = !lib_fast::DecodeNull(from);
4443 if (prs) {
4444 ok = lib_fast::DecodeSigned(from,parent.Value,true);
4445 if (!ok) {
4446 state.error << "fasttest.I32DfltOpt.Value: bad Signed" << eol;
4447 }
4448 }
4449 } else {
4450 parent.Value = 34;
4451 prs = true;
4452 }
4453 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
4454 }
4455 return ok;
4456}
4457
4458// --- fasttest.I32DfltOpt..FixEncode
4459void fasttest::I32DfltOpt_FixEncode(cstring& buf, fasttest::I32DfltOpt& parent, char soh) {
4460 if (Value_PresentQ(parent)) {
4461 buf << "1=" << parent.Value << soh;
4462 }
4463}
4464
4465// --- fasttest.I32Incr.base.CopyOut
4466// Copy fields out of row
4467void fasttest::parent_CopyOut(fasttest::I32Incr &row, fasttest::TemplateHeader &out) {
4468 // length: field value is computed
4469 // id: field value is computed
4470 (void)row;//only to avoid -Wunused-parameter
4471 (void)out;//only to avoid -Wunused-parameter
4472}
4473
4474// --- fasttest.I32Incr..ReadFieldMaybe
4475bool fasttest::I32Incr_ReadFieldMaybe(fasttest::I32Incr& parent, algo::strptr field, algo::strptr strval) {
4476 bool retval = true;
4477 fasttest::FieldId field_id;
4478 (void)value_SetStrptrMaybe(field_id,field);
4479 switch(field_id) {
4480 case fasttest_FieldId_base: {
4481 retval = false;
4482 break;
4483 }
4484 case fasttest_FieldId_length: {
4485 retval = false;
4486 break;
4487 }
4488 case fasttest_FieldId_id: {
4489 retval = false;
4490 break;
4491 }
4492 case fasttest_FieldId_Value97: {
4493 retval = i32_ReadStrptrMaybe(parent.Value97, strval);
4494 break;
4495 }
4496 default: break;
4497 }
4498 if (!retval) {
4499 algo_lib::AppendErrtext("attr",field);
4500 }
4501 return retval;
4502}
4503
4504// --- fasttest.I32Incr..ReadStrptrMaybe
4505// Read fields of fasttest::I32Incr from an ascii string.
4506// The format of the string is an ssim Tuple
4507bool fasttest::I32Incr_ReadStrptrMaybe(fasttest::I32Incr &parent, algo::strptr in_str) {
4508 bool retval = true;
4509 retval = algo::StripTypeTag(in_str, "fasttest.I32Incr");
4510 ind_beg(algo::Attr_curs, attr, in_str) {
4511 retval = retval && I32Incr_ReadFieldMaybe(parent, attr.name, attr.value);
4512 }ind_end;
4513 return retval;
4514}
4515
4516// --- fasttest.I32Incr..Print
4517// print string representation of ROW to string STR
4518// cfmt:fasttest.I32Incr.String printfmt:Tuple
4519void fasttest::I32Incr_Print(fasttest::I32Incr& row, algo::cstring& str) {
4520 algo::tempstr temp;
4521 str << "fasttest.I32Incr";
4522
4523 i32_Print(row.Value97, temp);
4524 PrintAttrSpaceReset(str,"Value97", temp);
4525}
4526
4527// --- fasttest.I32Incr..FastEncode
4528void fasttest::I32Incr_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32Incr& parent) {
4529 int index = ary_N(buf);
4530 u64 pmap(0);
4531 if (!tid_AssignedQ(state) || parent.id != state.tid) {
4532 lib_fast::EncodeUnsigned(buf,parent.id,false);
4533 lib_fast::SetPmapBit(pmap,0);
4534 }
4535 tid_SetAssigned(state);
4536 state.tid = parent.id;
4537 // Value97 signed increment mandatory
4538 if (Value97_AssignedQ(state)) {
4539 if (parent.Value97 != state.Value97 + 1) {
4540 lib_fast::EncodeSigned(buf,parent.Value97,false);
4541 lib_fast::SetPmapBit(pmap,1);
4542 }
4543 } else {
4544 if (parent.Value97 != 97) {
4545 lib_fast::EncodeSigned(buf,parent.Value97,false);
4546 lib_fast::SetPmapBit(pmap,1);
4547 }
4548 }
4549 state.Value97 = parent.Value97;
4550 Value97_SetAssigned(state);
4551 lib_fast::InsertPmap(buf,index,pmap);
4552}
4553
4554// --- fasttest.I32Incr..FastDecode
4555bool fasttest::I32Incr_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32Incr& parent) {
4556 bool ok = true;
4557 // Value97 signed increment mandatory
4558 if (ok) {
4559 bool prs = lib_fast::GetPmapBit(pmap,1);
4560 if (prs) {
4561 ok = lib_fast::DecodeSigned(from,parent.Value97,false);
4562 if (!ok) {
4563 state.error << "fasttest.I32Incr.Value97: bad Signed" << eol;
4564 }
4565 } else if (Value97_AssignedQ(state)) {
4566 parent.Value97 = state.Value97 + 1;
4567 } else {
4568 parent.Value97 = 97;
4569 }
4570 Value97_SetAssigned(state);
4571 state.Value97 = parent.Value97;
4572 }
4573 return ok;
4574}
4575
4576// --- fasttest.I32Incr..FixEncode
4577void fasttest::I32Incr_FixEncode(cstring& buf, fasttest::I32Incr& parent, char soh) {
4578 buf << "1=" << parent.Value97 << soh;
4579}
4580
4581// --- fasttest.I32IncrNV.base.CopyOut
4582// Copy fields out of row
4583void fasttest::parent_CopyOut(fasttest::I32IncrNV &row, fasttest::TemplateHeader &out) {
4584 // length: field value is computed
4585 // id: field value is computed
4586 (void)row;//only to avoid -Wunused-parameter
4587 (void)out;//only to avoid -Wunused-parameter
4588}
4589
4590// --- fasttest.I32IncrNV..ReadFieldMaybe
4591bool fasttest::I32IncrNV_ReadFieldMaybe(fasttest::I32IncrNV& parent, algo::strptr field, algo::strptr strval) {
4592 bool retval = true;
4593 fasttest::FieldId field_id;
4594 (void)value_SetStrptrMaybe(field_id,field);
4595 switch(field_id) {
4596 case fasttest_FieldId_base: {
4597 retval = false;
4598 break;
4599 }
4600 case fasttest_FieldId_length: {
4601 retval = false;
4602 break;
4603 }
4604 case fasttest_FieldId_id: {
4605 retval = false;
4606 break;
4607 }
4608 case fasttest_FieldId_Value98: {
4609 retval = i32_ReadStrptrMaybe(parent.Value98, strval);
4610 break;
4611 }
4612 default: break;
4613 }
4614 if (!retval) {
4615 algo_lib::AppendErrtext("attr",field);
4616 }
4617 return retval;
4618}
4619
4620// --- fasttest.I32IncrNV..ReadStrptrMaybe
4621// Read fields of fasttest::I32IncrNV from an ascii string.
4622// The format of the string is an ssim Tuple
4623bool fasttest::I32IncrNV_ReadStrptrMaybe(fasttest::I32IncrNV &parent, algo::strptr in_str) {
4624 bool retval = true;
4625 retval = algo::StripTypeTag(in_str, "fasttest.I32IncrNV");
4626 ind_beg(algo::Attr_curs, attr, in_str) {
4627 retval = retval && I32IncrNV_ReadFieldMaybe(parent, attr.name, attr.value);
4628 }ind_end;
4629 return retval;
4630}
4631
4632// --- fasttest.I32IncrNV..Print
4633// print string representation of ROW to string STR
4634// cfmt:fasttest.I32IncrNV.String printfmt:Tuple
4635void fasttest::I32IncrNV_Print(fasttest::I32IncrNV& row, algo::cstring& str) {
4636 algo::tempstr temp;
4637 str << "fasttest.I32IncrNV";
4638
4639 i32_Print(row.Value98, temp);
4640 PrintAttrSpaceReset(str,"Value98", temp);
4641}
4642
4643// --- fasttest.I32IncrNV..FastEncode
4644void fasttest::I32IncrNV_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32IncrNV& parent) {
4645 int index = ary_N(buf);
4646 u64 pmap(0);
4647 if (!tid_AssignedQ(state) || parent.id != state.tid) {
4648 lib_fast::EncodeUnsigned(buf,parent.id,false);
4649 lib_fast::SetPmapBit(pmap,0);
4650 }
4651 tid_SetAssigned(state);
4652 state.tid = parent.id;
4653 // Value98 signed increment mandatory
4654 if (Value98_AssignedQ(state)) {
4655 if (parent.Value98 != state.Value98 + 1) {
4656 lib_fast::EncodeSigned(buf,parent.Value98,false);
4657 lib_fast::SetPmapBit(pmap,1);
4658 }
4659 } else {
4660 lib_fast::EncodeSigned(buf,parent.Value98,false);
4661 lib_fast::SetPmapBit(pmap,1);
4662 }
4663 state.Value98 = parent.Value98;
4664 Value98_SetAssigned(state);
4665 lib_fast::InsertPmap(buf,index,pmap);
4666}
4667
4668// --- fasttest.I32IncrNV..FastDecode
4669bool fasttest::I32IncrNV_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32IncrNV& parent) {
4670 bool ok = true;
4671 // Value98 signed increment mandatory
4672 if (ok) {
4673 bool prs = lib_fast::GetPmapBit(pmap,1);
4674 if (prs) {
4675 ok = lib_fast::DecodeSigned(from,parent.Value98,false);
4676 if (!ok) {
4677 state.error << "fasttest.I32IncrNV.Value98: bad Signed" << eol;
4678 }
4679 } else if (Value98_AssignedQ(state)) {
4680 parent.Value98 = state.Value98 + 1;
4681 } else {
4682 ok = false;
4683 state.error << "fasttest.I32IncrNV.Value98: increment operator: previous value unassigned" << eol;
4684 }
4685 Value98_SetAssigned(state);
4686 state.Value98 = parent.Value98;
4687 }
4688 return ok;
4689}
4690
4691// --- fasttest.I32IncrNV..FixEncode
4692void fasttest::I32IncrNV_FixEncode(cstring& buf, fasttest::I32IncrNV& parent, char soh) {
4693 buf << "1=" << parent.Value98 << soh;
4694}
4695
4696// --- fasttest.I32IncrNull.base.CopyOut
4697// Copy fields out of row
4698void fasttest::parent_CopyOut(fasttest::I32IncrNull &row, fasttest::TemplateHeader &out) {
4699 // length: field value is computed
4700 // id: field value is computed
4701 (void)row;//only to avoid -Wunused-parameter
4702 (void)out;//only to avoid -Wunused-parameter
4703}
4704
4705// --- fasttest.I32IncrNull.Value100.ReadStrptrMaybe
4706inline static bool fasttest::Value100_ReadStrptrMaybe(fasttest::I32IncrNull &parent, algo::strptr in_str) {
4707 bool retval = true;
4708 i32 Value100_tmp;
4709 retval = i32_ReadStrptrMaybe(Value100_tmp, in_str);
4710 if (retval) {
4711 Value100_Set(parent, Value100_tmp);
4712 }
4713 return retval;
4714}
4715
4716// --- fasttest.I32IncrNull.pmask_bitcurs.Next
4717// proceed to next item
4718void fasttest::I32IncrNull_pmask_bitcurs_Next(I32IncrNull_pmask_bitcurs &curs) {
4719 ++curs.bit;
4720 int index = curs.bit / 32;
4721 int offset = curs.bit % 32;
4722 for (; index < curs.n_elems; ++index, offset = 0) {
4723 u64 rest = curs.elems[index] >> offset;
4724 if (rest) {
4725 offset += algo::u64_BitScanForward(rest);
4726 break;
4727 }
4728 }
4729 curs.bit = index * 32 + offset;
4730}
4731
4732// --- fasttest.I32IncrNull..ReadFieldMaybe
4733bool fasttest::I32IncrNull_ReadFieldMaybe(fasttest::I32IncrNull& parent, algo::strptr field, algo::strptr strval) {
4734 bool retval = true;
4735 fasttest::FieldId field_id;
4736 (void)value_SetStrptrMaybe(field_id,field);
4737 switch(field_id) {
4738 case fasttest_FieldId_base: {
4739 retval = false;
4740 break;
4741 }
4742 case fasttest_FieldId_length: {
4743 retval = false;
4744 break;
4745 }
4746 case fasttest_FieldId_id: {
4747 retval = false;
4748 break;
4749 }
4750 case fasttest_FieldId_pmask: {
4751 retval = false;
4752 break;
4753 }
4754 case fasttest_FieldId_Value100: {
4755 retval = Value100_ReadStrptrMaybe(parent, strval);
4756 if (retval) {
4757 pmask_qSetBit(parent, 0);
4758 }
4759 break;
4760 }
4761 default: break;
4762 }
4763 if (!retval) {
4764 algo_lib::AppendErrtext("attr",field);
4765 }
4766 return retval;
4767}
4768
4769// --- fasttest.I32IncrNull..ReadStrptrMaybe
4770// Read fields of fasttest::I32IncrNull from an ascii string.
4771// The format of the string is an ssim Tuple
4772bool fasttest::I32IncrNull_ReadStrptrMaybe(fasttest::I32IncrNull &parent, algo::strptr in_str) {
4773 bool retval = true;
4774 retval = algo::StripTypeTag(in_str, "fasttest.I32IncrNull");
4775 ind_beg(algo::Attr_curs, attr, in_str) {
4776 retval = retval && I32IncrNull_ReadFieldMaybe(parent, attr.name, attr.value);
4777 }ind_end;
4778 return retval;
4779}
4780
4781// --- fasttest.I32IncrNull..Print
4782// print string representation of ROW to string STR
4783// cfmt:fasttest.I32IncrNull.String printfmt:Tuple
4784void fasttest::I32IncrNull_Print(fasttest::I32IncrNull& row, algo::cstring& str) {
4785 algo::tempstr temp;
4786 str << "fasttest.I32IncrNull";
4787
4788 if (Value100_PresentQ(row)) {
4789 i32_Print(row.Value100, temp);
4790 PrintAttrSpaceReset(str,"Value100", temp);
4791 }
4792}
4793
4794// --- fasttest.I32IncrNull..FastEncode
4795void fasttest::I32IncrNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32IncrNull& parent) {
4796 int index = ary_N(buf);
4797 u64 pmap(0);
4798 if (!tid_AssignedQ(state) || parent.id != state.tid) {
4799 lib_fast::EncodeUnsigned(buf,parent.id,false);
4800 lib_fast::SetPmapBit(pmap,0);
4801 }
4802 tid_SetAssigned(state);
4803 state.tid = parent.id;
4804 // Value100 signed increment optional
4805 if (Value100_PresentQ(parent)) {
4806 if (Value100_AssignedQ(state)) {
4807 if (!Value100_PresentQ(state) || parent.Value100 != state.Value100 + 1) {
4808 lib_fast::EncodeSigned(buf,parent.Value100,true);
4809 lib_fast::SetPmapBit(pmap,1);
4810 }
4811 } else {
4812 lib_fast::EncodeSigned(buf,parent.Value100,true);
4813 lib_fast::SetPmapBit(pmap,1);
4814 }
4815 } else {
4816 if (!Value100_AssignedQ(state) || Value100_PresentQ(state)) {
4817 lib_fast::EncodeNull(buf);
4818 lib_fast::SetPmapBit(pmap,1);
4819 }
4820 }
4821 state.Value100 = parent.Value100;
4822 present_qSetBitVal(state,Value100_Present_GetBit(state),Value100_PresentQ(parent));
4823 Value100_SetAssigned(state);
4824 lib_fast::InsertPmap(buf,index,pmap);
4825}
4826
4827// --- fasttest.I32IncrNull..FastDecode
4828bool fasttest::I32IncrNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32IncrNull& parent) {
4829 bool ok = true;
4830 // Value100 signed increment optional
4831 if (ok) {
4832 bool prs = lib_fast::GetPmapBit(pmap,1);
4833 if (prs) {
4834 prs = !lib_fast::DecodeNull(from);
4835 if (prs) {
4836 ok = lib_fast::DecodeSigned(from,parent.Value100,true);
4837 if (!ok) {
4838 state.error << "fasttest.I32IncrNull.Value100: bad Signed" << eol;
4839 }
4840 }
4841 } else if (Value100_AssignedQ(state)) {
4842 parent.Value100 = state.Value100 + 1;
4843 prs = Value100_PresentQ(state);
4844 } else {
4845 prs = false;
4846 }
4847 pmask_qSetBitVal(parent,Value100_Present_GetBit(parent),prs);
4848 Value100_SetAssigned(state);
4849 present_qSetBitVal(state,Value100_Present_GetBit(state),prs);
4850 state.Value100 = parent.Value100;
4851 }
4852 return ok;
4853}
4854
4855// --- fasttest.I32IncrNull..FixEncode
4856void fasttest::I32IncrNull_FixEncode(cstring& buf, fasttest::I32IncrNull& parent, char soh) {
4857 if (Value100_PresentQ(parent)) {
4858 buf << "1=" << parent.Value100 << soh;
4859 }
4860}
4861
4862// --- fasttest.I32IncrOpt.base.CopyOut
4863// Copy fields out of row
4864void fasttest::parent_CopyOut(fasttest::I32IncrOpt &row, fasttest::TemplateHeader &out) {
4865 // length: field value is computed
4866 // id: field value is computed
4867 (void)row;//only to avoid -Wunused-parameter
4868 (void)out;//only to avoid -Wunused-parameter
4869}
4870
4871// --- fasttest.I32IncrOpt.Value99.ReadStrptrMaybe
4872inline static bool fasttest::Value99_ReadStrptrMaybe(fasttest::I32IncrOpt &parent, algo::strptr in_str) {
4873 bool retval = true;
4874 i32 Value99_tmp;
4875 retval = i32_ReadStrptrMaybe(Value99_tmp, in_str);
4876 if (retval) {
4877 Value99_Set(parent, Value99_tmp);
4878 }
4879 return retval;
4880}
4881
4882// --- fasttest.I32IncrOpt.pmask_bitcurs.Next
4883// proceed to next item
4884void fasttest::I32IncrOpt_pmask_bitcurs_Next(I32IncrOpt_pmask_bitcurs &curs) {
4885 ++curs.bit;
4886 int index = curs.bit / 32;
4887 int offset = curs.bit % 32;
4888 for (; index < curs.n_elems; ++index, offset = 0) {
4889 u64 rest = curs.elems[index] >> offset;
4890 if (rest) {
4891 offset += algo::u64_BitScanForward(rest);
4892 break;
4893 }
4894 }
4895 curs.bit = index * 32 + offset;
4896}
4897
4898// --- fasttest.I32IncrOpt..ReadFieldMaybe
4899bool fasttest::I32IncrOpt_ReadFieldMaybe(fasttest::I32IncrOpt& parent, algo::strptr field, algo::strptr strval) {
4900 bool retval = true;
4901 fasttest::FieldId field_id;
4902 (void)value_SetStrptrMaybe(field_id,field);
4903 switch(field_id) {
4904 case fasttest_FieldId_base: {
4905 retval = false;
4906 break;
4907 }
4908 case fasttest_FieldId_length: {
4909 retval = false;
4910 break;
4911 }
4912 case fasttest_FieldId_id: {
4913 retval = false;
4914 break;
4915 }
4916 case fasttest_FieldId_pmask: {
4917 retval = false;
4918 break;
4919 }
4920 case fasttest_FieldId_Value99: {
4921 retval = Value99_ReadStrptrMaybe(parent, strval);
4922 if (retval) {
4923 pmask_qSetBit(parent, 0);
4924 }
4925 break;
4926 }
4927 default: break;
4928 }
4929 if (!retval) {
4930 algo_lib::AppendErrtext("attr",field);
4931 }
4932 return retval;
4933}
4934
4935// --- fasttest.I32IncrOpt..ReadStrptrMaybe
4936// Read fields of fasttest::I32IncrOpt from an ascii string.
4937// The format of the string is an ssim Tuple
4938bool fasttest::I32IncrOpt_ReadStrptrMaybe(fasttest::I32IncrOpt &parent, algo::strptr in_str) {
4939 bool retval = true;
4940 retval = algo::StripTypeTag(in_str, "fasttest.I32IncrOpt");
4941 ind_beg(algo::Attr_curs, attr, in_str) {
4942 retval = retval && I32IncrOpt_ReadFieldMaybe(parent, attr.name, attr.value);
4943 }ind_end;
4944 return retval;
4945}
4946
4947// --- fasttest.I32IncrOpt..Print
4948// print string representation of ROW to string STR
4949// cfmt:fasttest.I32IncrOpt.String printfmt:Tuple
4950void fasttest::I32IncrOpt_Print(fasttest::I32IncrOpt& row, algo::cstring& str) {
4951 algo::tempstr temp;
4952 str << "fasttest.I32IncrOpt";
4953
4954 if (Value99_PresentQ(row)) {
4955 i32_Print(row.Value99, temp);
4956 PrintAttrSpaceReset(str,"Value99", temp);
4957 }
4958}
4959
4960// --- fasttest.I32IncrOpt..FastEncode
4961void fasttest::I32IncrOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32IncrOpt& parent) {
4962 int index = ary_N(buf);
4963 u64 pmap(0);
4964 if (!tid_AssignedQ(state) || parent.id != state.tid) {
4965 lib_fast::EncodeUnsigned(buf,parent.id,false);
4966 lib_fast::SetPmapBit(pmap,0);
4967 }
4968 tid_SetAssigned(state);
4969 state.tid = parent.id;
4970 // Value99 signed increment optional
4971 if (Value99_PresentQ(parent)) {
4972 if (Value99_AssignedQ(state)) {
4973 if (!Value99_PresentQ(state) || parent.Value99 != state.Value99 + 1) {
4974 lib_fast::EncodeSigned(buf,parent.Value99,true);
4975 lib_fast::SetPmapBit(pmap,1);
4976 }
4977 } else {
4978 if (parent.Value99 != 99) {
4979 lib_fast::EncodeSigned(buf,parent.Value99,true);
4980 lib_fast::SetPmapBit(pmap,1);
4981 }
4982 }
4983 } else {
4984 if (!Value99_AssignedQ(state) || Value99_PresentQ(state)) {
4985 lib_fast::EncodeNull(buf);
4986 lib_fast::SetPmapBit(pmap,1);
4987 }
4988 }
4989 state.Value99 = parent.Value99;
4990 present_qSetBitVal(state,Value99_Present_GetBit(state),Value99_PresentQ(parent));
4991 Value99_SetAssigned(state);
4992 lib_fast::InsertPmap(buf,index,pmap);
4993}
4994
4995// --- fasttest.I32IncrOpt..FastDecode
4996bool fasttest::I32IncrOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32IncrOpt& parent) {
4997 bool ok = true;
4998 // Value99 signed increment optional
4999 if (ok) {
5000 bool prs = lib_fast::GetPmapBit(pmap,1);
5001 if (prs) {
5002 prs = !lib_fast::DecodeNull(from);
5003 if (prs) {
5004 ok = lib_fast::DecodeSigned(from,parent.Value99,true);
5005 if (!ok) {
5006 state.error << "fasttest.I32IncrOpt.Value99: bad Signed" << eol;
5007 }
5008 }
5009 } else if (Value99_AssignedQ(state)) {
5010 parent.Value99 = state.Value99 + 1;
5011 prs = Value99_PresentQ(state);
5012 } else {
5013 parent.Value99 = 99;
5014 prs = true;
5015 }
5016 pmask_qSetBitVal(parent,Value99_Present_GetBit(parent),prs);
5017 Value99_SetAssigned(state);
5018 present_qSetBitVal(state,Value99_Present_GetBit(state),prs);
5019 state.Value99 = parent.Value99;
5020 }
5021 return ok;
5022}
5023
5024// --- fasttest.I32IncrOpt..FixEncode
5025void fasttest::I32IncrOpt_FixEncode(cstring& buf, fasttest::I32IncrOpt& parent, char soh) {
5026 if (Value99_PresentQ(parent)) {
5027 buf << "1=" << parent.Value99 << soh;
5028 }
5029}
5030
5031// --- fasttest.I32None.base.CopyOut
5032// Copy fields out of row
5033void fasttest::parent_CopyOut(fasttest::I32None &row, fasttest::TemplateHeader &out) {
5034 // length: field value is computed
5035 // id: field value is computed
5036 (void)row;//only to avoid -Wunused-parameter
5037 (void)out;//only to avoid -Wunused-parameter
5038}
5039
5040// --- fasttest.I32None..ReadFieldMaybe
5041bool fasttest::I32None_ReadFieldMaybe(fasttest::I32None& parent, algo::strptr field, algo::strptr strval) {
5042 bool retval = true;
5043 fasttest::FieldId field_id;
5044 (void)value_SetStrptrMaybe(field_id,field);
5045 switch(field_id) {
5046 case fasttest_FieldId_base: {
5047 retval = false;
5048 break;
5049 }
5050 case fasttest_FieldId_length: {
5051 retval = false;
5052 break;
5053 }
5054 case fasttest_FieldId_id: {
5055 retval = false;
5056 break;
5057 }
5058 case fasttest_FieldId_Value: {
5059 retval = i32_ReadStrptrMaybe(parent.Value, strval);
5060 break;
5061 }
5062 default: break;
5063 }
5064 if (!retval) {
5065 algo_lib::AppendErrtext("attr",field);
5066 }
5067 return retval;
5068}
5069
5070// --- fasttest.I32None..ReadStrptrMaybe
5071// Read fields of fasttest::I32None from an ascii string.
5072// The format of the string is an ssim Tuple
5073bool fasttest::I32None_ReadStrptrMaybe(fasttest::I32None &parent, algo::strptr in_str) {
5074 bool retval = true;
5075 retval = algo::StripTypeTag(in_str, "fasttest.I32None");
5076 ind_beg(algo::Attr_curs, attr, in_str) {
5077 retval = retval && I32None_ReadFieldMaybe(parent, attr.name, attr.value);
5078 }ind_end;
5079 return retval;
5080}
5081
5082// --- fasttest.I32None..Print
5083// print string representation of ROW to string STR
5084// cfmt:fasttest.I32None.String printfmt:Tuple
5085void fasttest::I32None_Print(fasttest::I32None& row, algo::cstring& str) {
5086 algo::tempstr temp;
5087 str << "fasttest.I32None";
5088
5089 i32_Print(row.Value, temp);
5090 PrintAttrSpaceReset(str,"Value", temp);
5091}
5092
5093// --- fasttest.I32None..FastEncode
5094void fasttest::I32None_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32None& parent) {
5095 int index = ary_N(buf);
5096 u64 pmap(0);
5097 if (!tid_AssignedQ(state) || parent.id != state.tid) {
5098 lib_fast::EncodeUnsigned(buf,parent.id,false);
5099 lib_fast::SetPmapBit(pmap,0);
5100 }
5101 tid_SetAssigned(state);
5102 state.tid = parent.id;
5103 // Value signed none mandatory
5104 lib_fast::EncodeSigned(buf,parent.Value,false);
5105 lib_fast::InsertPmap(buf,index,pmap);
5106}
5107
5108// --- fasttest.I32None..FastDecode
5109bool fasttest::I32None_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32None& parent) {
5110 bool ok = true;
5111 // Value signed none mandatory
5112 if (ok) {
5113 ok = lib_fast::DecodeSigned(from,parent.Value,false);
5114 if (!ok) {
5115 state.error << "fasttest.I32None.Value: bad Signed" << eol;
5116 }
5117 }
5118 (void)pmap;//only to avoid -Wunused-parameter
5119 return ok;
5120}
5121
5122// --- fasttest.I32None..FixEncode
5123void fasttest::I32None_FixEncode(cstring& buf, fasttest::I32None& parent, char soh) {
5124 buf << "1=" << parent.Value << soh;
5125}
5126
5127// --- fasttest.I32NoneOpt.base.CopyOut
5128// Copy fields out of row
5129void fasttest::parent_CopyOut(fasttest::I32NoneOpt &row, fasttest::TemplateHeader &out) {
5130 // length: field value is computed
5131 // id: field value is computed
5132 (void)row;//only to avoid -Wunused-parameter
5133 (void)out;//only to avoid -Wunused-parameter
5134}
5135
5136// --- fasttest.I32NoneOpt.Value.ReadStrptrMaybe
5137inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::I32NoneOpt &parent, algo::strptr in_str) {
5138 bool retval = true;
5139 i32 Value_tmp;
5140 retval = i32_ReadStrptrMaybe(Value_tmp, in_str);
5141 if (retval) {
5142 Value_Set(parent, Value_tmp);
5143 }
5144 return retval;
5145}
5146
5147// --- fasttest.I32NoneOpt.pmask_bitcurs.Next
5148// proceed to next item
5149void fasttest::I32NoneOpt_pmask_bitcurs_Next(I32NoneOpt_pmask_bitcurs &curs) {
5150 ++curs.bit;
5151 int index = curs.bit / 32;
5152 int offset = curs.bit % 32;
5153 for (; index < curs.n_elems; ++index, offset = 0) {
5154 u64 rest = curs.elems[index] >> offset;
5155 if (rest) {
5156 offset += algo::u64_BitScanForward(rest);
5157 break;
5158 }
5159 }
5160 curs.bit = index * 32 + offset;
5161}
5162
5163// --- fasttest.I32NoneOpt..ReadFieldMaybe
5164bool fasttest::I32NoneOpt_ReadFieldMaybe(fasttest::I32NoneOpt& parent, algo::strptr field, algo::strptr strval) {
5165 bool retval = true;
5166 fasttest::FieldId field_id;
5167 (void)value_SetStrptrMaybe(field_id,field);
5168 switch(field_id) {
5169 case fasttest_FieldId_base: {
5170 retval = false;
5171 break;
5172 }
5173 case fasttest_FieldId_length: {
5174 retval = false;
5175 break;
5176 }
5177 case fasttest_FieldId_id: {
5178 retval = false;
5179 break;
5180 }
5181 case fasttest_FieldId_pmask: {
5182 retval = false;
5183 break;
5184 }
5185 case fasttest_FieldId_Value: {
5186 retval = Value_ReadStrptrMaybe(parent, strval);
5187 if (retval) {
5188 pmask_qSetBit(parent, 0);
5189 }
5190 break;
5191 }
5192 default: break;
5193 }
5194 if (!retval) {
5195 algo_lib::AppendErrtext("attr",field);
5196 }
5197 return retval;
5198}
5199
5200// --- fasttest.I32NoneOpt..ReadStrptrMaybe
5201// Read fields of fasttest::I32NoneOpt from an ascii string.
5202// The format of the string is an ssim Tuple
5203bool fasttest::I32NoneOpt_ReadStrptrMaybe(fasttest::I32NoneOpt &parent, algo::strptr in_str) {
5204 bool retval = true;
5205 retval = algo::StripTypeTag(in_str, "fasttest.I32NoneOpt");
5206 ind_beg(algo::Attr_curs, attr, in_str) {
5207 retval = retval && I32NoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
5208 }ind_end;
5209 return retval;
5210}
5211
5212// --- fasttest.I32NoneOpt..Print
5213// print string representation of ROW to string STR
5214// cfmt:fasttest.I32NoneOpt.String printfmt:Tuple
5215void fasttest::I32NoneOpt_Print(fasttest::I32NoneOpt& row, algo::cstring& str) {
5216 algo::tempstr temp;
5217 str << "fasttest.I32NoneOpt";
5218
5219 if (Value_PresentQ(row)) {
5220 i32_Print(row.Value, temp);
5221 PrintAttrSpaceReset(str,"Value", temp);
5222 }
5223}
5224
5225// --- fasttest.I32NoneOpt..FastEncode
5226void fasttest::I32NoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::I32NoneOpt& parent) {
5227 int index = ary_N(buf);
5228 u64 pmap(0);
5229 if (!tid_AssignedQ(state) || parent.id != state.tid) {
5230 lib_fast::EncodeUnsigned(buf,parent.id,false);
5231 lib_fast::SetPmapBit(pmap,0);
5232 }
5233 tid_SetAssigned(state);
5234 state.tid = parent.id;
5235 // Value signed none optional
5236 if (Value_PresentQ(parent)) {
5237 lib_fast::EncodeSigned(buf,parent.Value,true);
5238 } else {
5239 lib_fast::EncodeNull(buf);
5240 }
5241 lib_fast::InsertPmap(buf,index,pmap);
5242}
5243
5244// --- fasttest.I32NoneOpt..FastDecode
5245bool fasttest::I32NoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::I32NoneOpt& parent) {
5246 bool ok = true;
5247 // Value signed none optional
5248 if (ok) {
5249 bool prs = !lib_fast::DecodeNull(from);
5250 if (prs) {
5251 ok = lib_fast::DecodeSigned(from,parent.Value,true);
5252 if (!ok) {
5253 state.error << "fasttest.I32NoneOpt.Value: bad Signed" << eol;
5254 }
5255 }
5256 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
5257 }
5258 (void)pmap;//only to avoid -Wunused-parameter
5259 return ok;
5260}
5261
5262// --- fasttest.I32NoneOpt..FixEncode
5263void fasttest::I32NoneOpt_FixEncode(cstring& buf, fasttest::I32NoneOpt& parent, char soh) {
5264 if (Value_PresentQ(parent)) {
5265 buf << "1=" << parent.Value << soh;
5266 }
5267}
5268
5269// --- fasttest.MsgPmap.base.CopyOut
5270// Copy fields out of row
5271void fasttest::parent_CopyOut(fasttest::MsgPmap &row, fasttest::TemplateHeader &out) {
5272 // length: field value is computed
5273 // id: field value is computed
5274 (void)row;//only to avoid -Wunused-parameter
5275 (void)out;//only to avoid -Wunused-parameter
5276}
5277
5278// --- fasttest.MsgPmap.pmask_bitcurs.Next
5279// proceed to next item
5280void fasttest::MsgPmap_pmask_bitcurs_Next(MsgPmap_pmask_bitcurs &curs) {
5281 ++curs.bit;
5282 int index = curs.bit / 64;
5283 int offset = curs.bit % 64;
5284 for (; index < curs.n_elems; ++index, offset = 0) {
5285 u64 rest = curs.elems[index] >> offset;
5286 if (rest) {
5287 offset += algo::u64_BitScanForward(rest);
5288 break;
5289 }
5290 }
5291 curs.bit = index * 64 + offset;
5292}
5293
5294// --- fasttest.MsgPmap..ReadFieldMaybe
5295bool fasttest::MsgPmap_ReadFieldMaybe(fasttest::MsgPmap& parent, algo::strptr field, algo::strptr strval) {
5296 bool retval = true;
5297 fasttest::FieldId field_id;
5298 (void)value_SetStrptrMaybe(field_id,field);
5299 switch(field_id) {
5300 case fasttest_FieldId_base: {
5301 retval = false;
5302 break;
5303 }
5304 case fasttest_FieldId_length: {
5305 retval = false;
5306 break;
5307 }
5308 case fasttest_FieldId_id: {
5309 retval = false;
5310 break;
5311 }
5312 case fasttest_FieldId_pmask: {
5313 retval = false;
5314 break;
5315 }
5316 case fasttest_FieldId_Value1: {
5317 retval = true;
5318 if (retval) {
5319 pmask_qSetBit(parent, 0);
5320 }
5321 break;
5322 }
5323 case fasttest_FieldId_Value2: {
5324 retval = true;
5325 if (retval) {
5326 pmask_qSetBit(parent, 11);
5327 }
5328 break;
5329 }
5330 case fasttest_FieldId_Value3: {
5331 retval = true;
5332 if (retval) {
5333 pmask_qSetBit(parent, 22);
5334 }
5335 break;
5336 }
5337 case fasttest_FieldId_Value4: {
5338 retval = true;
5339 if (retval) {
5340 pmask_qSetBit(parent, 33);
5341 }
5342 break;
5343 }
5344 case fasttest_FieldId_Value5: {
5345 retval = true;
5346 if (retval) {
5347 pmask_qSetBit(parent, 44);
5348 }
5349 break;
5350 }
5351 case fasttest_FieldId_Value6: {
5352 retval = true;
5353 if (retval) {
5354 pmask_qSetBit(parent, 55);
5355 }
5356 break;
5357 }
5358 case fasttest_FieldId_Value7: {
5359 retval = true;
5360 if (retval) {
5361 pmask_qSetBit(parent, 60);
5362 }
5363 break;
5364 }
5365 case fasttest_FieldId_Value8: {
5366 retval = true;
5367 if (retval) {
5368 pmask_qSetBit(parent, 61);
5369 }
5370 break;
5371 }
5372 case fasttest_FieldId_Value9: {
5373 retval = true;
5374 if (retval) {
5375 pmask_qSetBit(parent, 62);
5376 }
5377 break;
5378 }
5379 case fasttest_FieldId_Value10: {
5380 retval = true;
5381 if (retval) {
5382 pmask_qSetBit(parent, 1);
5383 }
5384 break;
5385 }
5386 case fasttest_FieldId_Value11: {
5387 retval = true;
5388 if (retval) {
5389 pmask_qSetBit(parent, 2);
5390 }
5391 break;
5392 }
5393 case fasttest_FieldId_Value12: {
5394 retval = true;
5395 if (retval) {
5396 pmask_qSetBit(parent, 3);
5397 }
5398 break;
5399 }
5400 case fasttest_FieldId_Value13: {
5401 retval = true;
5402 if (retval) {
5403 pmask_qSetBit(parent, 4);
5404 }
5405 break;
5406 }
5407 case fasttest_FieldId_Value14: {
5408 retval = true;
5409 if (retval) {
5410 pmask_qSetBit(parent, 5);
5411 }
5412 break;
5413 }
5414 case fasttest_FieldId_Value15: {
5415 retval = true;
5416 if (retval) {
5417 pmask_qSetBit(parent, 6);
5418 }
5419 break;
5420 }
5421 case fasttest_FieldId_Value16: {
5422 retval = true;
5423 if (retval) {
5424 pmask_qSetBit(parent, 7);
5425 }
5426 break;
5427 }
5428 case fasttest_FieldId_Value17: {
5429 retval = true;
5430 if (retval) {
5431 pmask_qSetBit(parent, 8);
5432 }
5433 break;
5434 }
5435 case fasttest_FieldId_Value18: {
5436 retval = true;
5437 if (retval) {
5438 pmask_qSetBit(parent, 9);
5439 }
5440 break;
5441 }
5442 case fasttest_FieldId_Value19: {
5443 retval = true;
5444 if (retval) {
5445 pmask_qSetBit(parent, 10);
5446 }
5447 break;
5448 }
5449 case fasttest_FieldId_Value20: {
5450 retval = true;
5451 if (retval) {
5452 pmask_qSetBit(parent, 12);
5453 }
5454 break;
5455 }
5456 case fasttest_FieldId_Value21: {
5457 retval = true;
5458 if (retval) {
5459 pmask_qSetBit(parent, 13);
5460 }
5461 break;
5462 }
5463 case fasttest_FieldId_Value22: {
5464 retval = true;
5465 if (retval) {
5466 pmask_qSetBit(parent, 14);
5467 }
5468 break;
5469 }
5470 case fasttest_FieldId_Value23: {
5471 retval = true;
5472 if (retval) {
5473 pmask_qSetBit(parent, 15);
5474 }
5475 break;
5476 }
5477 case fasttest_FieldId_Value24: {
5478 retval = true;
5479 if (retval) {
5480 pmask_qSetBit(parent, 16);
5481 }
5482 break;
5483 }
5484 case fasttest_FieldId_Value25: {
5485 retval = true;
5486 if (retval) {
5487 pmask_qSetBit(parent, 17);
5488 }
5489 break;
5490 }
5491 case fasttest_FieldId_Value26: {
5492 retval = true;
5493 if (retval) {
5494 pmask_qSetBit(parent, 18);
5495 }
5496 break;
5497 }
5498 case fasttest_FieldId_Value27: {
5499 retval = true;
5500 if (retval) {
5501 pmask_qSetBit(parent, 19);
5502 }
5503 break;
5504 }
5505 case fasttest_FieldId_Value28: {
5506 retval = true;
5507 if (retval) {
5508 pmask_qSetBit(parent, 20);
5509 }
5510 break;
5511 }
5512 case fasttest_FieldId_Value29: {
5513 retval = true;
5514 if (retval) {
5515 pmask_qSetBit(parent, 21);
5516 }
5517 break;
5518 }
5519 case fasttest_FieldId_Value30: {
5520 retval = true;
5521 if (retval) {
5522 pmask_qSetBit(parent, 23);
5523 }
5524 break;
5525 }
5526 case fasttest_FieldId_Value31: {
5527 retval = true;
5528 if (retval) {
5529 pmask_qSetBit(parent, 24);
5530 }
5531 break;
5532 }
5533 case fasttest_FieldId_Value32: {
5534 retval = true;
5535 if (retval) {
5536 pmask_qSetBit(parent, 25);
5537 }
5538 break;
5539 }
5540 case fasttest_FieldId_Value33: {
5541 retval = true;
5542 if (retval) {
5543 pmask_qSetBit(parent, 26);
5544 }
5545 break;
5546 }
5547 case fasttest_FieldId_Value34: {
5548 retval = true;
5549 if (retval) {
5550 pmask_qSetBit(parent, 27);
5551 }
5552 break;
5553 }
5554 case fasttest_FieldId_Value35: {
5555 retval = true;
5556 if (retval) {
5557 pmask_qSetBit(parent, 28);
5558 }
5559 break;
5560 }
5561 case fasttest_FieldId_Value36: {
5562 retval = true;
5563 if (retval) {
5564 pmask_qSetBit(parent, 29);
5565 }
5566 break;
5567 }
5568 case fasttest_FieldId_Value37: {
5569 retval = true;
5570 if (retval) {
5571 pmask_qSetBit(parent, 30);
5572 }
5573 break;
5574 }
5575 case fasttest_FieldId_Value38: {
5576 retval = true;
5577 if (retval) {
5578 pmask_qSetBit(parent, 31);
5579 }
5580 break;
5581 }
5582 case fasttest_FieldId_Value39: {
5583 retval = true;
5584 if (retval) {
5585 pmask_qSetBit(parent, 32);
5586 }
5587 break;
5588 }
5589 case fasttest_FieldId_Value40: {
5590 retval = true;
5591 if (retval) {
5592 pmask_qSetBit(parent, 34);
5593 }
5594 break;
5595 }
5596 case fasttest_FieldId_Value41: {
5597 retval = true;
5598 if (retval) {
5599 pmask_qSetBit(parent, 35);
5600 }
5601 break;
5602 }
5603 case fasttest_FieldId_Value42: {
5604 retval = true;
5605 if (retval) {
5606 pmask_qSetBit(parent, 36);
5607 }
5608 break;
5609 }
5610 case fasttest_FieldId_Value43: {
5611 retval = true;
5612 if (retval) {
5613 pmask_qSetBit(parent, 37);
5614 }
5615 break;
5616 }
5617 case fasttest_FieldId_Value44: {
5618 retval = true;
5619 if (retval) {
5620 pmask_qSetBit(parent, 38);
5621 }
5622 break;
5623 }
5624 case fasttest_FieldId_Value45: {
5625 retval = true;
5626 if (retval) {
5627 pmask_qSetBit(parent, 39);
5628 }
5629 break;
5630 }
5631 case fasttest_FieldId_Value46: {
5632 retval = true;
5633 if (retval) {
5634 pmask_qSetBit(parent, 40);
5635 }
5636 break;
5637 }
5638 case fasttest_FieldId_Value47: {
5639 retval = true;
5640 if (retval) {
5641 pmask_qSetBit(parent, 41);
5642 }
5643 break;
5644 }
5645 case fasttest_FieldId_Value48: {
5646 retval = true;
5647 if (retval) {
5648 pmask_qSetBit(parent, 42);
5649 }
5650 break;
5651 }
5652 case fasttest_FieldId_Value49: {
5653 retval = true;
5654 if (retval) {
5655 pmask_qSetBit(parent, 43);
5656 }
5657 break;
5658 }
5659 case fasttest_FieldId_Value50: {
5660 retval = true;
5661 if (retval) {
5662 pmask_qSetBit(parent, 45);
5663 }
5664 break;
5665 }
5666 case fasttest_FieldId_Value51: {
5667 retval = true;
5668 if (retval) {
5669 pmask_qSetBit(parent, 46);
5670 }
5671 break;
5672 }
5673 case fasttest_FieldId_Value52: {
5674 retval = true;
5675 if (retval) {
5676 pmask_qSetBit(parent, 47);
5677 }
5678 break;
5679 }
5680 case fasttest_FieldId_Value53: {
5681 retval = true;
5682 if (retval) {
5683 pmask_qSetBit(parent, 48);
5684 }
5685 break;
5686 }
5687 case fasttest_FieldId_Value54: {
5688 retval = true;
5689 if (retval) {
5690 pmask_qSetBit(parent, 49);
5691 }
5692 break;
5693 }
5694 case fasttest_FieldId_Value55: {
5695 retval = true;
5696 if (retval) {
5697 pmask_qSetBit(parent, 50);
5698 }
5699 break;
5700 }
5701 case fasttest_FieldId_Value56: {
5702 retval = true;
5703 if (retval) {
5704 pmask_qSetBit(parent, 51);
5705 }
5706 break;
5707 }
5708 case fasttest_FieldId_Value57: {
5709 retval = true;
5710 if (retval) {
5711 pmask_qSetBit(parent, 52);
5712 }
5713 break;
5714 }
5715 case fasttest_FieldId_Value58: {
5716 retval = true;
5717 if (retval) {
5718 pmask_qSetBit(parent, 53);
5719 }
5720 break;
5721 }
5722 case fasttest_FieldId_Value59: {
5723 retval = true;
5724 if (retval) {
5725 pmask_qSetBit(parent, 54);
5726 }
5727 break;
5728 }
5729 case fasttest_FieldId_Value60: {
5730 retval = true;
5731 if (retval) {
5732 pmask_qSetBit(parent, 56);
5733 }
5734 break;
5735 }
5736 case fasttest_FieldId_Value61: {
5737 retval = true;
5738 if (retval) {
5739 pmask_qSetBit(parent, 57);
5740 }
5741 break;
5742 }
5743 case fasttest_FieldId_Value62: {
5744 retval = true;
5745 if (retval) {
5746 pmask_qSetBit(parent, 58);
5747 }
5748 break;
5749 }
5750 case fasttest_FieldId_Value63: {
5751 retval = true;
5752 if (retval) {
5753 pmask_qSetBit(parent, 59);
5754 }
5755 break;
5756 }
5757 default: break;
5758 }
5759 if (!retval) {
5760 algo_lib::AppendErrtext("attr",field);
5761 }
5762 (void)strval;//only to avoid -Wunused-parameter
5763 return retval;
5764}
5765
5766// --- fasttest.MsgPmap..ReadStrptrMaybe
5767// Read fields of fasttest::MsgPmap from an ascii string.
5768// The format of the string is an ssim Tuple
5769bool fasttest::MsgPmap_ReadStrptrMaybe(fasttest::MsgPmap &parent, algo::strptr in_str) {
5770 bool retval = true;
5771 retval = algo::StripTypeTag(in_str, "fasttest.MsgPmap");
5772 ind_beg(algo::Attr_curs, attr, in_str) {
5773 retval = retval && MsgPmap_ReadFieldMaybe(parent, attr.name, attr.value);
5774 }ind_end;
5775 return retval;
5776}
5777
5778// --- fasttest.MsgPmap..Init
5779// Set all fields to initial values.
5780void fasttest::MsgPmap_Init(fasttest::MsgPmap& parent) {
5781 parent.length = u32(ssizeof(parent) + (0));
5782 parent.id = u32(151);
5783 parent.pmask = u64(0);
5784}
5785
5786// --- fasttest.MsgPmap..Print
5787// print string representation of ROW to string STR
5788// cfmt:fasttest.MsgPmap.String printfmt:Tuple
5789void fasttest::MsgPmap_Print(fasttest::MsgPmap& row, algo::cstring& str) {
5790 algo::tempstr temp;
5791 str << "fasttest.MsgPmap";
5792
5793 if (Value1_PresentQ(row)) {
5794 u32_Print(Value1_Get(row), temp);
5795 PrintAttrSpaceReset(str,"Value1", temp);
5796 }
5797
5798 if (Value2_PresentQ(row)) {
5799 u32_Print(Value2_Get(row), temp);
5800 PrintAttrSpaceReset(str,"Value2", temp);
5801 }
5802
5803 if (Value3_PresentQ(row)) {
5804 u32_Print(Value3_Get(row), temp);
5805 PrintAttrSpaceReset(str,"Value3", temp);
5806 }
5807
5808 if (Value4_PresentQ(row)) {
5809 u32_Print(Value4_Get(row), temp);
5810 PrintAttrSpaceReset(str,"Value4", temp);
5811 }
5812
5813 if (Value5_PresentQ(row)) {
5814 u32_Print(Value5_Get(row), temp);
5815 PrintAttrSpaceReset(str,"Value5", temp);
5816 }
5817
5818 if (Value6_PresentQ(row)) {
5819 u32_Print(Value6_Get(row), temp);
5820 PrintAttrSpaceReset(str,"Value6", temp);
5821 }
5822
5823 if (Value7_PresentQ(row)) {
5824 u32_Print(Value7_Get(row), temp);
5825 PrintAttrSpaceReset(str,"Value7", temp);
5826 }
5827
5828 if (Value8_PresentQ(row)) {
5829 u32_Print(Value8_Get(row), temp);
5830 PrintAttrSpaceReset(str,"Value8", temp);
5831 }
5832
5833 if (Value9_PresentQ(row)) {
5834 u32_Print(Value9_Get(row), temp);
5835 PrintAttrSpaceReset(str,"Value9", temp);
5836 }
5837
5838 if (Value10_PresentQ(row)) {
5839 u32_Print(Value10_Get(row), temp);
5840 PrintAttrSpaceReset(str,"Value10", temp);
5841 }
5842
5843 if (Value11_PresentQ(row)) {
5844 u32_Print(Value11_Get(row), temp);
5845 PrintAttrSpaceReset(str,"Value11", temp);
5846 }
5847
5848 if (Value12_PresentQ(row)) {
5849 u32_Print(Value12_Get(row), temp);
5850 PrintAttrSpaceReset(str,"Value12", temp);
5851 }
5852
5853 if (Value13_PresentQ(row)) {
5854 u32_Print(Value13_Get(row), temp);
5855 PrintAttrSpaceReset(str,"Value13", temp);
5856 }
5857
5858 if (Value14_PresentQ(row)) {
5859 u32_Print(Value14_Get(row), temp);
5860 PrintAttrSpaceReset(str,"Value14", temp);
5861 }
5862
5863 if (Value15_PresentQ(row)) {
5864 u32_Print(Value15_Get(row), temp);
5865 PrintAttrSpaceReset(str,"Value15", temp);
5866 }
5867
5868 if (Value16_PresentQ(row)) {
5869 u32_Print(Value16_Get(row), temp);
5870 PrintAttrSpaceReset(str,"Value16", temp);
5871 }
5872
5873 if (Value17_PresentQ(row)) {
5874 u32_Print(Value17_Get(row), temp);
5875 PrintAttrSpaceReset(str,"Value17", temp);
5876 }
5877
5878 if (Value18_PresentQ(row)) {
5879 u32_Print(Value18_Get(row), temp);
5880 PrintAttrSpaceReset(str,"Value18", temp);
5881 }
5882
5883 if (Value19_PresentQ(row)) {
5884 u32_Print(Value19_Get(row), temp);
5885 PrintAttrSpaceReset(str,"Value19", temp);
5886 }
5887
5888 if (Value20_PresentQ(row)) {
5889 u32_Print(Value20_Get(row), temp);
5890 PrintAttrSpaceReset(str,"Value20", temp);
5891 }
5892
5893 if (Value21_PresentQ(row)) {
5894 u32_Print(Value21_Get(row), temp);
5895 PrintAttrSpaceReset(str,"Value21", temp);
5896 }
5897
5898 if (Value22_PresentQ(row)) {
5899 u32_Print(Value22_Get(row), temp);
5900 PrintAttrSpaceReset(str,"Value22", temp);
5901 }
5902
5903 if (Value23_PresentQ(row)) {
5904 u32_Print(Value23_Get(row), temp);
5905 PrintAttrSpaceReset(str,"Value23", temp);
5906 }
5907
5908 if (Value24_PresentQ(row)) {
5909 u32_Print(Value24_Get(row), temp);
5910 PrintAttrSpaceReset(str,"Value24", temp);
5911 }
5912
5913 if (Value25_PresentQ(row)) {
5914 u32_Print(Value25_Get(row), temp);
5915 PrintAttrSpaceReset(str,"Value25", temp);
5916 }
5917
5918 if (Value26_PresentQ(row)) {
5919 u32_Print(Value26_Get(row), temp);
5920 PrintAttrSpaceReset(str,"Value26", temp);
5921 }
5922
5923 if (Value27_PresentQ(row)) {
5924 u32_Print(Value27_Get(row), temp);
5925 PrintAttrSpaceReset(str,"Value27", temp);
5926 }
5927
5928 if (Value28_PresentQ(row)) {
5929 u32_Print(Value28_Get(row), temp);
5930 PrintAttrSpaceReset(str,"Value28", temp);
5931 }
5932
5933 if (Value29_PresentQ(row)) {
5934 u32_Print(Value29_Get(row), temp);
5935 PrintAttrSpaceReset(str,"Value29", temp);
5936 }
5937
5938 if (Value30_PresentQ(row)) {
5939 u32_Print(Value30_Get(row), temp);
5940 PrintAttrSpaceReset(str,"Value30", temp);
5941 }
5942
5943 if (Value31_PresentQ(row)) {
5944 u32_Print(Value31_Get(row), temp);
5945 PrintAttrSpaceReset(str,"Value31", temp);
5946 }
5947
5948 if (Value32_PresentQ(row)) {
5949 u32_Print(Value32_Get(row), temp);
5950 PrintAttrSpaceReset(str,"Value32", temp);
5951 }
5952
5953 if (Value33_PresentQ(row)) {
5954 u32_Print(Value33_Get(row), temp);
5955 PrintAttrSpaceReset(str,"Value33", temp);
5956 }
5957
5958 if (Value34_PresentQ(row)) {
5959 u32_Print(Value34_Get(row), temp);
5960 PrintAttrSpaceReset(str,"Value34", temp);
5961 }
5962
5963 if (Value35_PresentQ(row)) {
5964 u32_Print(Value35_Get(row), temp);
5965 PrintAttrSpaceReset(str,"Value35", temp);
5966 }
5967
5968 if (Value36_PresentQ(row)) {
5969 u32_Print(Value36_Get(row), temp);
5970 PrintAttrSpaceReset(str,"Value36", temp);
5971 }
5972
5973 if (Value37_PresentQ(row)) {
5974 u32_Print(Value37_Get(row), temp);
5975 PrintAttrSpaceReset(str,"Value37", temp);
5976 }
5977
5978 if (Value38_PresentQ(row)) {
5979 u32_Print(Value38_Get(row), temp);
5980 PrintAttrSpaceReset(str,"Value38", temp);
5981 }
5982
5983 if (Value39_PresentQ(row)) {
5984 u32_Print(Value39_Get(row), temp);
5985 PrintAttrSpaceReset(str,"Value39", temp);
5986 }
5987
5988 if (Value40_PresentQ(row)) {
5989 u32_Print(Value40_Get(row), temp);
5990 PrintAttrSpaceReset(str,"Value40", temp);
5991 }
5992
5993 if (Value41_PresentQ(row)) {
5994 u32_Print(Value41_Get(row), temp);
5995 PrintAttrSpaceReset(str,"Value41", temp);
5996 }
5997
5998 if (Value42_PresentQ(row)) {
5999 u32_Print(Value42_Get(row), temp);
6000 PrintAttrSpaceReset(str,"Value42", temp);
6001 }
6002
6003 if (Value43_PresentQ(row)) {
6004 u32_Print(Value43_Get(row), temp);
6005 PrintAttrSpaceReset(str,"Value43", temp);
6006 }
6007
6008 if (Value44_PresentQ(row)) {
6009 u32_Print(Value44_Get(row), temp);
6010 PrintAttrSpaceReset(str,"Value44", temp);
6011 }
6012
6013 if (Value45_PresentQ(row)) {
6014 u32_Print(Value45_Get(row), temp);
6015 PrintAttrSpaceReset(str,"Value45", temp);
6016 }
6017
6018 if (Value46_PresentQ(row)) {
6019 u32_Print(Value46_Get(row), temp);
6020 PrintAttrSpaceReset(str,"Value46", temp);
6021 }
6022
6023 if (Value47_PresentQ(row)) {
6024 u32_Print(Value47_Get(row), temp);
6025 PrintAttrSpaceReset(str,"Value47", temp);
6026 }
6027
6028 if (Value48_PresentQ(row)) {
6029 u32_Print(Value48_Get(row), temp);
6030 PrintAttrSpaceReset(str,"Value48", temp);
6031 }
6032
6033 if (Value49_PresentQ(row)) {
6034 u32_Print(Value49_Get(row), temp);
6035 PrintAttrSpaceReset(str,"Value49", temp);
6036 }
6037
6038 if (Value50_PresentQ(row)) {
6039 u32_Print(Value50_Get(row), temp);
6040 PrintAttrSpaceReset(str,"Value50", temp);
6041 }
6042
6043 if (Value51_PresentQ(row)) {
6044 u32_Print(Value51_Get(row), temp);
6045 PrintAttrSpaceReset(str,"Value51", temp);
6046 }
6047
6048 if (Value52_PresentQ(row)) {
6049 u32_Print(Value52_Get(row), temp);
6050 PrintAttrSpaceReset(str,"Value52", temp);
6051 }
6052
6053 if (Value53_PresentQ(row)) {
6054 u32_Print(Value53_Get(row), temp);
6055 PrintAttrSpaceReset(str,"Value53", temp);
6056 }
6057
6058 if (Value54_PresentQ(row)) {
6059 u32_Print(Value54_Get(row), temp);
6060 PrintAttrSpaceReset(str,"Value54", temp);
6061 }
6062
6063 if (Value55_PresentQ(row)) {
6064 u32_Print(Value55_Get(row), temp);
6065 PrintAttrSpaceReset(str,"Value55", temp);
6066 }
6067
6068 if (Value56_PresentQ(row)) {
6069 u32_Print(Value56_Get(row), temp);
6070 PrintAttrSpaceReset(str,"Value56", temp);
6071 }
6072
6073 if (Value57_PresentQ(row)) {
6074 u32_Print(Value57_Get(row), temp);
6075 PrintAttrSpaceReset(str,"Value57", temp);
6076 }
6077
6078 if (Value58_PresentQ(row)) {
6079 u32_Print(Value58_Get(row), temp);
6080 PrintAttrSpaceReset(str,"Value58", temp);
6081 }
6082
6083 if (Value59_PresentQ(row)) {
6084 u32_Print(Value59_Get(row), temp);
6085 PrintAttrSpaceReset(str,"Value59", temp);
6086 }
6087
6088 if (Value60_PresentQ(row)) {
6089 u32_Print(Value60_Get(row), temp);
6090 PrintAttrSpaceReset(str,"Value60", temp);
6091 }
6092
6093 if (Value61_PresentQ(row)) {
6094 u32_Print(Value61_Get(row), temp);
6095 PrintAttrSpaceReset(str,"Value61", temp);
6096 }
6097
6098 if (Value62_PresentQ(row)) {
6099 u32_Print(Value62_Get(row), temp);
6100 PrintAttrSpaceReset(str,"Value62", temp);
6101 }
6102
6103 if (Value63_PresentQ(row)) {
6104 u32_Print(Value63_Get(row), temp);
6105 PrintAttrSpaceReset(str,"Value63", temp);
6106 }
6107}
6108
6109// --- fasttest.MsgPmap..FastEncode
6110void fasttest::MsgPmap_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::MsgPmap& parent) {
6111 int index = ary_N(buf);
6112 u64 pmap(0);
6113 if (!tid_AssignedQ(state) || parent.id != state.tid) {
6114 lib_fast::EncodeUnsigned(buf,parent.id,false);
6115 lib_fast::SetPmapBit(pmap,0);
6116 }
6117 tid_SetAssigned(state);
6118 state.tid = parent.id;
6119 // Value1 unsigned constant optional
6120 if (Value1_PresentQ(parent)) {
6121 lib_fast::SetPmapBit(pmap,1);
6122 }
6123 // Value2 unsigned constant optional
6124 if (Value2_PresentQ(parent)) {
6125 lib_fast::SetPmapBit(pmap,2);
6126 }
6127 // Value3 unsigned constant optional
6128 if (Value3_PresentQ(parent)) {
6129 lib_fast::SetPmapBit(pmap,3);
6130 }
6131 // Value4 unsigned constant optional
6132 if (Value4_PresentQ(parent)) {
6133 lib_fast::SetPmapBit(pmap,4);
6134 }
6135 // Value5 unsigned constant optional
6136 if (Value5_PresentQ(parent)) {
6137 lib_fast::SetPmapBit(pmap,5);
6138 }
6139 // Value6 unsigned constant optional
6140 if (Value6_PresentQ(parent)) {
6141 lib_fast::SetPmapBit(pmap,6);
6142 }
6143 // Value7 unsigned constant optional
6144 if (Value7_PresentQ(parent)) {
6145 lib_fast::SetPmapBit(pmap,7);
6146 }
6147 // Value8 unsigned constant optional
6148 if (Value8_PresentQ(parent)) {
6149 lib_fast::SetPmapBit(pmap,8);
6150 }
6151 // Value9 unsigned constant optional
6152 if (Value9_PresentQ(parent)) {
6153 lib_fast::SetPmapBit(pmap,9);
6154 }
6155 // Value10 unsigned constant optional
6156 if (Value10_PresentQ(parent)) {
6157 lib_fast::SetPmapBit(pmap,10);
6158 }
6159 // Value11 unsigned constant optional
6160 if (Value11_PresentQ(parent)) {
6161 lib_fast::SetPmapBit(pmap,11);
6162 }
6163 // Value12 unsigned constant optional
6164 if (Value12_PresentQ(parent)) {
6165 lib_fast::SetPmapBit(pmap,12);
6166 }
6167 // Value13 unsigned constant optional
6168 if (Value13_PresentQ(parent)) {
6169 lib_fast::SetPmapBit(pmap,13);
6170 }
6171 // Value14 unsigned constant optional
6172 if (Value14_PresentQ(parent)) {
6173 lib_fast::SetPmapBit(pmap,14);
6174 }
6175 // Value15 unsigned constant optional
6176 if (Value15_PresentQ(parent)) {
6177 lib_fast::SetPmapBit(pmap,15);
6178 }
6179 // Value16 unsigned constant optional
6180 if (Value16_PresentQ(parent)) {
6181 lib_fast::SetPmapBit(pmap,16);
6182 }
6183 // Value17 unsigned constant optional
6184 if (Value17_PresentQ(parent)) {
6185 lib_fast::SetPmapBit(pmap,17);
6186 }
6187 // Value18 unsigned constant optional
6188 if (Value18_PresentQ(parent)) {
6189 lib_fast::SetPmapBit(pmap,18);
6190 }
6191 // Value19 unsigned constant optional
6192 if (Value19_PresentQ(parent)) {
6193 lib_fast::SetPmapBit(pmap,19);
6194 }
6195 // Value20 unsigned constant optional
6196 if (Value20_PresentQ(parent)) {
6197 lib_fast::SetPmapBit(pmap,20);
6198 }
6199 // Value21 unsigned constant optional
6200 if (Value21_PresentQ(parent)) {
6201 lib_fast::SetPmapBit(pmap,21);
6202 }
6203 // Value22 unsigned constant optional
6204 if (Value22_PresentQ(parent)) {
6205 lib_fast::SetPmapBit(pmap,22);
6206 }
6207 // Value23 unsigned constant optional
6208 if (Value23_PresentQ(parent)) {
6209 lib_fast::SetPmapBit(pmap,23);
6210 }
6211 // Value24 unsigned constant optional
6212 if (Value24_PresentQ(parent)) {
6213 lib_fast::SetPmapBit(pmap,24);
6214 }
6215 // Value25 unsigned constant optional
6216 if (Value25_PresentQ(parent)) {
6217 lib_fast::SetPmapBit(pmap,25);
6218 }
6219 // Value26 unsigned constant optional
6220 if (Value26_PresentQ(parent)) {
6221 lib_fast::SetPmapBit(pmap,26);
6222 }
6223 // Value27 unsigned constant optional
6224 if (Value27_PresentQ(parent)) {
6225 lib_fast::SetPmapBit(pmap,27);
6226 }
6227 // Value28 unsigned constant optional
6228 if (Value28_PresentQ(parent)) {
6229 lib_fast::SetPmapBit(pmap,28);
6230 }
6231 // Value29 unsigned constant optional
6232 if (Value29_PresentQ(parent)) {
6233 lib_fast::SetPmapBit(pmap,29);
6234 }
6235 // Value30 unsigned constant optional
6236 if (Value30_PresentQ(parent)) {
6237 lib_fast::SetPmapBit(pmap,30);
6238 }
6239 // Value31 unsigned constant optional
6240 if (Value31_PresentQ(parent)) {
6241 lib_fast::SetPmapBit(pmap,31);
6242 }
6243 // Value32 unsigned constant optional
6244 if (Value32_PresentQ(parent)) {
6245 lib_fast::SetPmapBit(pmap,32);
6246 }
6247 // Value33 unsigned constant optional
6248 if (Value33_PresentQ(parent)) {
6249 lib_fast::SetPmapBit(pmap,33);
6250 }
6251 // Value34 unsigned constant optional
6252 if (Value34_PresentQ(parent)) {
6253 lib_fast::SetPmapBit(pmap,34);
6254 }
6255 // Value35 unsigned constant optional
6256 if (Value35_PresentQ(parent)) {
6257 lib_fast::SetPmapBit(pmap,35);
6258 }
6259 // Value36 unsigned constant optional
6260 if (Value36_PresentQ(parent)) {
6261 lib_fast::SetPmapBit(pmap,36);
6262 }
6263 // Value37 unsigned constant optional
6264 if (Value37_PresentQ(parent)) {
6265 lib_fast::SetPmapBit(pmap,37);
6266 }
6267 // Value38 unsigned constant optional
6268 if (Value38_PresentQ(parent)) {
6269 lib_fast::SetPmapBit(pmap,38);
6270 }
6271 // Value39 unsigned constant optional
6272 if (Value39_PresentQ(parent)) {
6273 lib_fast::SetPmapBit(pmap,39);
6274 }
6275 // Value40 unsigned constant optional
6276 if (Value40_PresentQ(parent)) {
6277 lib_fast::SetPmapBit(pmap,40);
6278 }
6279 // Value41 unsigned constant optional
6280 if (Value41_PresentQ(parent)) {
6281 lib_fast::SetPmapBit(pmap,41);
6282 }
6283 // Value42 unsigned constant optional
6284 if (Value42_PresentQ(parent)) {
6285 lib_fast::SetPmapBit(pmap,42);
6286 }
6287 // Value43 unsigned constant optional
6288 if (Value43_PresentQ(parent)) {
6289 lib_fast::SetPmapBit(pmap,43);
6290 }
6291 // Value44 unsigned constant optional
6292 if (Value44_PresentQ(parent)) {
6293 lib_fast::SetPmapBit(pmap,44);
6294 }
6295 // Value45 unsigned constant optional
6296 if (Value45_PresentQ(parent)) {
6297 lib_fast::SetPmapBit(pmap,45);
6298 }
6299 // Value46 unsigned constant optional
6300 if (Value46_PresentQ(parent)) {
6301 lib_fast::SetPmapBit(pmap,46);
6302 }
6303 // Value47 unsigned constant optional
6304 if (Value47_PresentQ(parent)) {
6305 lib_fast::SetPmapBit(pmap,47);
6306 }
6307 // Value48 unsigned constant optional
6308 if (Value48_PresentQ(parent)) {
6309 lib_fast::SetPmapBit(pmap,48);
6310 }
6311 // Value49 unsigned constant optional
6312 if (Value49_PresentQ(parent)) {
6313 lib_fast::SetPmapBit(pmap,49);
6314 }
6315 // Value50 unsigned constant optional
6316 if (Value50_PresentQ(parent)) {
6317 lib_fast::SetPmapBit(pmap,50);
6318 }
6319 // Value51 unsigned constant optional
6320 if (Value51_PresentQ(parent)) {
6321 lib_fast::SetPmapBit(pmap,51);
6322 }
6323 // Value52 unsigned constant optional
6324 if (Value52_PresentQ(parent)) {
6325 lib_fast::SetPmapBit(pmap,52);
6326 }
6327 // Value53 unsigned constant optional
6328 if (Value53_PresentQ(parent)) {
6329 lib_fast::SetPmapBit(pmap,53);
6330 }
6331 // Value54 unsigned constant optional
6332 if (Value54_PresentQ(parent)) {
6333 lib_fast::SetPmapBit(pmap,54);
6334 }
6335 // Value55 unsigned constant optional
6336 if (Value55_PresentQ(parent)) {
6337 lib_fast::SetPmapBit(pmap,55);
6338 }
6339 // Value56 unsigned constant optional
6340 if (Value56_PresentQ(parent)) {
6341 lib_fast::SetPmapBit(pmap,56);
6342 }
6343 // Value57 unsigned constant optional
6344 if (Value57_PresentQ(parent)) {
6345 lib_fast::SetPmapBit(pmap,57);
6346 }
6347 // Value58 unsigned constant optional
6348 if (Value58_PresentQ(parent)) {
6349 lib_fast::SetPmapBit(pmap,58);
6350 }
6351 // Value59 unsigned constant optional
6352 if (Value59_PresentQ(parent)) {
6353 lib_fast::SetPmapBit(pmap,59);
6354 }
6355 // Value60 unsigned constant optional
6356 if (Value60_PresentQ(parent)) {
6357 lib_fast::SetPmapBit(pmap,60);
6358 }
6359 // Value61 unsigned constant optional
6360 if (Value61_PresentQ(parent)) {
6361 lib_fast::SetPmapBit(pmap,61);
6362 }
6363 // Value62 unsigned constant optional
6364 if (Value62_PresentQ(parent)) {
6365 lib_fast::SetPmapBit(pmap,62);
6366 }
6367 // Value63 unsigned constant optional
6368 if (Value63_PresentQ(parent)) {
6369 lib_fast::SetPmapBit(pmap,63);
6370 }
6371 lib_fast::InsertPmap(buf,index,pmap);
6372}
6373
6374// --- fasttest.MsgPmap..FastDecode
6375bool fasttest::MsgPmap_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::MsgPmap& parent) {
6376 bool ok = true;
6377 // Value1 unsigned constant optional
6378 if (ok) {
6379 bool prs = lib_fast::GetPmapBit(pmap,1);
6380 pmask_qSetBitVal(parent,Value1_Present_GetBit(parent),prs);
6381 }
6382 // Value2 unsigned constant optional
6383 if (ok) {
6384 bool prs = lib_fast::GetPmapBit(pmap,2);
6385 pmask_qSetBitVal(parent,Value2_Present_GetBit(parent),prs);
6386 }
6387 // Value3 unsigned constant optional
6388 if (ok) {
6389 bool prs = lib_fast::GetPmapBit(pmap,3);
6390 pmask_qSetBitVal(parent,Value3_Present_GetBit(parent),prs);
6391 }
6392 // Value4 unsigned constant optional
6393 if (ok) {
6394 bool prs = lib_fast::GetPmapBit(pmap,4);
6395 pmask_qSetBitVal(parent,Value4_Present_GetBit(parent),prs);
6396 }
6397 // Value5 unsigned constant optional
6398 if (ok) {
6399 bool prs = lib_fast::GetPmapBit(pmap,5);
6400 pmask_qSetBitVal(parent,Value5_Present_GetBit(parent),prs);
6401 }
6402 // Value6 unsigned constant optional
6403 if (ok) {
6404 bool prs = lib_fast::GetPmapBit(pmap,6);
6405 pmask_qSetBitVal(parent,Value6_Present_GetBit(parent),prs);
6406 }
6407 // Value7 unsigned constant optional
6408 if (ok) {
6409 bool prs = lib_fast::GetPmapBit(pmap,7);
6410 pmask_qSetBitVal(parent,Value7_Present_GetBit(parent),prs);
6411 }
6412 // Value8 unsigned constant optional
6413 if (ok) {
6414 bool prs = lib_fast::GetPmapBit(pmap,8);
6415 pmask_qSetBitVal(parent,Value8_Present_GetBit(parent),prs);
6416 }
6417 // Value9 unsigned constant optional
6418 if (ok) {
6419 bool prs = lib_fast::GetPmapBit(pmap,9);
6420 pmask_qSetBitVal(parent,Value9_Present_GetBit(parent),prs);
6421 }
6422 // Value10 unsigned constant optional
6423 if (ok) {
6424 bool prs = lib_fast::GetPmapBit(pmap,10);
6425 pmask_qSetBitVal(parent,Value10_Present_GetBit(parent),prs);
6426 }
6427 // Value11 unsigned constant optional
6428 if (ok) {
6429 bool prs = lib_fast::GetPmapBit(pmap,11);
6430 pmask_qSetBitVal(parent,Value11_Present_GetBit(parent),prs);
6431 }
6432 // Value12 unsigned constant optional
6433 if (ok) {
6434 bool prs = lib_fast::GetPmapBit(pmap,12);
6435 pmask_qSetBitVal(parent,Value12_Present_GetBit(parent),prs);
6436 }
6437 // Value13 unsigned constant optional
6438 if (ok) {
6439 bool prs = lib_fast::GetPmapBit(pmap,13);
6440 pmask_qSetBitVal(parent,Value13_Present_GetBit(parent),prs);
6441 }
6442 // Value14 unsigned constant optional
6443 if (ok) {
6444 bool prs = lib_fast::GetPmapBit(pmap,14);
6445 pmask_qSetBitVal(parent,Value14_Present_GetBit(parent),prs);
6446 }
6447 // Value15 unsigned constant optional
6448 if (ok) {
6449 bool prs = lib_fast::GetPmapBit(pmap,15);
6450 pmask_qSetBitVal(parent,Value15_Present_GetBit(parent),prs);
6451 }
6452 // Value16 unsigned constant optional
6453 if (ok) {
6454 bool prs = lib_fast::GetPmapBit(pmap,16);
6455 pmask_qSetBitVal(parent,Value16_Present_GetBit(parent),prs);
6456 }
6457 // Value17 unsigned constant optional
6458 if (ok) {
6459 bool prs = lib_fast::GetPmapBit(pmap,17);
6460 pmask_qSetBitVal(parent,Value17_Present_GetBit(parent),prs);
6461 }
6462 // Value18 unsigned constant optional
6463 if (ok) {
6464 bool prs = lib_fast::GetPmapBit(pmap,18);
6465 pmask_qSetBitVal(parent,Value18_Present_GetBit(parent),prs);
6466 }
6467 // Value19 unsigned constant optional
6468 if (ok) {
6469 bool prs = lib_fast::GetPmapBit(pmap,19);
6470 pmask_qSetBitVal(parent,Value19_Present_GetBit(parent),prs);
6471 }
6472 // Value20 unsigned constant optional
6473 if (ok) {
6474 bool prs = lib_fast::GetPmapBit(pmap,20);
6475 pmask_qSetBitVal(parent,Value20_Present_GetBit(parent),prs);
6476 }
6477 // Value21 unsigned constant optional
6478 if (ok) {
6479 bool prs = lib_fast::GetPmapBit(pmap,21);
6480 pmask_qSetBitVal(parent,Value21_Present_GetBit(parent),prs);
6481 }
6482 // Value22 unsigned constant optional
6483 if (ok) {
6484 bool prs = lib_fast::GetPmapBit(pmap,22);
6485 pmask_qSetBitVal(parent,Value22_Present_GetBit(parent),prs);
6486 }
6487 // Value23 unsigned constant optional
6488 if (ok) {
6489 bool prs = lib_fast::GetPmapBit(pmap,23);
6490 pmask_qSetBitVal(parent,Value23_Present_GetBit(parent),prs);
6491 }
6492 // Value24 unsigned constant optional
6493 if (ok) {
6494 bool prs = lib_fast::GetPmapBit(pmap,24);
6495 pmask_qSetBitVal(parent,Value24_Present_GetBit(parent),prs);
6496 }
6497 // Value25 unsigned constant optional
6498 if (ok) {
6499 bool prs = lib_fast::GetPmapBit(pmap,25);
6500 pmask_qSetBitVal(parent,Value25_Present_GetBit(parent),prs);
6501 }
6502 // Value26 unsigned constant optional
6503 if (ok) {
6504 bool prs = lib_fast::GetPmapBit(pmap,26);
6505 pmask_qSetBitVal(parent,Value26_Present_GetBit(parent),prs);
6506 }
6507 // Value27 unsigned constant optional
6508 if (ok) {
6509 bool prs = lib_fast::GetPmapBit(pmap,27);
6510 pmask_qSetBitVal(parent,Value27_Present_GetBit(parent),prs);
6511 }
6512 // Value28 unsigned constant optional
6513 if (ok) {
6514 bool prs = lib_fast::GetPmapBit(pmap,28);
6515 pmask_qSetBitVal(parent,Value28_Present_GetBit(parent),prs);
6516 }
6517 // Value29 unsigned constant optional
6518 if (ok) {
6519 bool prs = lib_fast::GetPmapBit(pmap,29);
6520 pmask_qSetBitVal(parent,Value29_Present_GetBit(parent),prs);
6521 }
6522 // Value30 unsigned constant optional
6523 if (ok) {
6524 bool prs = lib_fast::GetPmapBit(pmap,30);
6525 pmask_qSetBitVal(parent,Value30_Present_GetBit(parent),prs);
6526 }
6527 // Value31 unsigned constant optional
6528 if (ok) {
6529 bool prs = lib_fast::GetPmapBit(pmap,31);
6530 pmask_qSetBitVal(parent,Value31_Present_GetBit(parent),prs);
6531 }
6532 // Value32 unsigned constant optional
6533 if (ok) {
6534 bool prs = lib_fast::GetPmapBit(pmap,32);
6535 pmask_qSetBitVal(parent,Value32_Present_GetBit(parent),prs);
6536 }
6537 // Value33 unsigned constant optional
6538 if (ok) {
6539 bool prs = lib_fast::GetPmapBit(pmap,33);
6540 pmask_qSetBitVal(parent,Value33_Present_GetBit(parent),prs);
6541 }
6542 // Value34 unsigned constant optional
6543 if (ok) {
6544 bool prs = lib_fast::GetPmapBit(pmap,34);
6545 pmask_qSetBitVal(parent,Value34_Present_GetBit(parent),prs);
6546 }
6547 // Value35 unsigned constant optional
6548 if (ok) {
6549 bool prs = lib_fast::GetPmapBit(pmap,35);
6550 pmask_qSetBitVal(parent,Value35_Present_GetBit(parent),prs);
6551 }
6552 // Value36 unsigned constant optional
6553 if (ok) {
6554 bool prs = lib_fast::GetPmapBit(pmap,36);
6555 pmask_qSetBitVal(parent,Value36_Present_GetBit(parent),prs);
6556 }
6557 // Value37 unsigned constant optional
6558 if (ok) {
6559 bool prs = lib_fast::GetPmapBit(pmap,37);
6560 pmask_qSetBitVal(parent,Value37_Present_GetBit(parent),prs);
6561 }
6562 // Value38 unsigned constant optional
6563 if (ok) {
6564 bool prs = lib_fast::GetPmapBit(pmap,38);
6565 pmask_qSetBitVal(parent,Value38_Present_GetBit(parent),prs);
6566 }
6567 // Value39 unsigned constant optional
6568 if (ok) {
6569 bool prs = lib_fast::GetPmapBit(pmap,39);
6570 pmask_qSetBitVal(parent,Value39_Present_GetBit(parent),prs);
6571 }
6572 // Value40 unsigned constant optional
6573 if (ok) {
6574 bool prs = lib_fast::GetPmapBit(pmap,40);
6575 pmask_qSetBitVal(parent,Value40_Present_GetBit(parent),prs);
6576 }
6577 // Value41 unsigned constant optional
6578 if (ok) {
6579 bool prs = lib_fast::GetPmapBit(pmap,41);
6580 pmask_qSetBitVal(parent,Value41_Present_GetBit(parent),prs);
6581 }
6582 // Value42 unsigned constant optional
6583 if (ok) {
6584 bool prs = lib_fast::GetPmapBit(pmap,42);
6585 pmask_qSetBitVal(parent,Value42_Present_GetBit(parent),prs);
6586 }
6587 // Value43 unsigned constant optional
6588 if (ok) {
6589 bool prs = lib_fast::GetPmapBit(pmap,43);
6590 pmask_qSetBitVal(parent,Value43_Present_GetBit(parent),prs);
6591 }
6592 // Value44 unsigned constant optional
6593 if (ok) {
6594 bool prs = lib_fast::GetPmapBit(pmap,44);
6595 pmask_qSetBitVal(parent,Value44_Present_GetBit(parent),prs);
6596 }
6597 // Value45 unsigned constant optional
6598 if (ok) {
6599 bool prs = lib_fast::GetPmapBit(pmap,45);
6600 pmask_qSetBitVal(parent,Value45_Present_GetBit(parent),prs);
6601 }
6602 // Value46 unsigned constant optional
6603 if (ok) {
6604 bool prs = lib_fast::GetPmapBit(pmap,46);
6605 pmask_qSetBitVal(parent,Value46_Present_GetBit(parent),prs);
6606 }
6607 // Value47 unsigned constant optional
6608 if (ok) {
6609 bool prs = lib_fast::GetPmapBit(pmap,47);
6610 pmask_qSetBitVal(parent,Value47_Present_GetBit(parent),prs);
6611 }
6612 // Value48 unsigned constant optional
6613 if (ok) {
6614 bool prs = lib_fast::GetPmapBit(pmap,48);
6615 pmask_qSetBitVal(parent,Value48_Present_GetBit(parent),prs);
6616 }
6617 // Value49 unsigned constant optional
6618 if (ok) {
6619 bool prs = lib_fast::GetPmapBit(pmap,49);
6620 pmask_qSetBitVal(parent,Value49_Present_GetBit(parent),prs);
6621 }
6622 // Value50 unsigned constant optional
6623 if (ok) {
6624 bool prs = lib_fast::GetPmapBit(pmap,50);
6625 pmask_qSetBitVal(parent,Value50_Present_GetBit(parent),prs);
6626 }
6627 // Value51 unsigned constant optional
6628 if (ok) {
6629 bool prs = lib_fast::GetPmapBit(pmap,51);
6630 pmask_qSetBitVal(parent,Value51_Present_GetBit(parent),prs);
6631 }
6632 // Value52 unsigned constant optional
6633 if (ok) {
6634 bool prs = lib_fast::GetPmapBit(pmap,52);
6635 pmask_qSetBitVal(parent,Value52_Present_GetBit(parent),prs);
6636 }
6637 // Value53 unsigned constant optional
6638 if (ok) {
6639 bool prs = lib_fast::GetPmapBit(pmap,53);
6640 pmask_qSetBitVal(parent,Value53_Present_GetBit(parent),prs);
6641 }
6642 // Value54 unsigned constant optional
6643 if (ok) {
6644 bool prs = lib_fast::GetPmapBit(pmap,54);
6645 pmask_qSetBitVal(parent,Value54_Present_GetBit(parent),prs);
6646 }
6647 // Value55 unsigned constant optional
6648 if (ok) {
6649 bool prs = lib_fast::GetPmapBit(pmap,55);
6650 pmask_qSetBitVal(parent,Value55_Present_GetBit(parent),prs);
6651 }
6652 // Value56 unsigned constant optional
6653 if (ok) {
6654 bool prs = lib_fast::GetPmapBit(pmap,56);
6655 pmask_qSetBitVal(parent,Value56_Present_GetBit(parent),prs);
6656 }
6657 // Value57 unsigned constant optional
6658 if (ok) {
6659 bool prs = lib_fast::GetPmapBit(pmap,57);
6660 pmask_qSetBitVal(parent,Value57_Present_GetBit(parent),prs);
6661 }
6662 // Value58 unsigned constant optional
6663 if (ok) {
6664 bool prs = lib_fast::GetPmapBit(pmap,58);
6665 pmask_qSetBitVal(parent,Value58_Present_GetBit(parent),prs);
6666 }
6667 // Value59 unsigned constant optional
6668 if (ok) {
6669 bool prs = lib_fast::GetPmapBit(pmap,59);
6670 pmask_qSetBitVal(parent,Value59_Present_GetBit(parent),prs);
6671 }
6672 // Value60 unsigned constant optional
6673 if (ok) {
6674 bool prs = lib_fast::GetPmapBit(pmap,60);
6675 pmask_qSetBitVal(parent,Value60_Present_GetBit(parent),prs);
6676 }
6677 // Value61 unsigned constant optional
6678 if (ok) {
6679 bool prs = lib_fast::GetPmapBit(pmap,61);
6680 pmask_qSetBitVal(parent,Value61_Present_GetBit(parent),prs);
6681 }
6682 // Value62 unsigned constant optional
6683 if (ok) {
6684 bool prs = lib_fast::GetPmapBit(pmap,62);
6685 pmask_qSetBitVal(parent,Value62_Present_GetBit(parent),prs);
6686 }
6687 // Value63 unsigned constant optional
6688 if (ok) {
6689 bool prs = lib_fast::GetPmapBit(pmap,63);
6690 pmask_qSetBitVal(parent,Value63_Present_GetBit(parent),prs);
6691 }
6692 (void)from;//only to avoid -Wunused-parameter
6693 (void)state;//only to avoid -Wunused-parameter
6694 return ok;
6695}
6696
6697// --- fasttest.MsgPmap..FixEncode
6698void fasttest::MsgPmap_FixEncode(cstring& buf, fasttest::MsgPmap& parent, char soh) {
6699 if (Value1_PresentQ(parent)) {
6700 buf << "1=" << Value1_Get(parent) << soh;
6701 }
6702 if (Value2_PresentQ(parent)) {
6703 buf << "2=" << Value2_Get(parent) << soh;
6704 }
6705 if (Value3_PresentQ(parent)) {
6706 buf << "3=" << Value3_Get(parent) << soh;
6707 }
6708 if (Value4_PresentQ(parent)) {
6709 buf << "4=" << Value4_Get(parent) << soh;
6710 }
6711 if (Value5_PresentQ(parent)) {
6712 buf << "5=" << Value5_Get(parent) << soh;
6713 }
6714 if (Value6_PresentQ(parent)) {
6715 buf << "6=" << Value6_Get(parent) << soh;
6716 }
6717 if (Value7_PresentQ(parent)) {
6718 buf << "7=" << Value7_Get(parent) << soh;
6719 }
6720 if (Value8_PresentQ(parent)) {
6721 buf << "8=" << Value8_Get(parent) << soh;
6722 }
6723 if (Value9_PresentQ(parent)) {
6724 buf << "9=" << Value9_Get(parent) << soh;
6725 }
6726 if (Value10_PresentQ(parent)) {
6727 buf << "10=" << Value10_Get(parent) << soh;
6728 }
6729 if (Value11_PresentQ(parent)) {
6730 buf << "11=" << Value11_Get(parent) << soh;
6731 }
6732 if (Value12_PresentQ(parent)) {
6733 buf << "12=" << Value12_Get(parent) << soh;
6734 }
6735 if (Value13_PresentQ(parent)) {
6736 buf << "13=" << Value13_Get(parent) << soh;
6737 }
6738 if (Value14_PresentQ(parent)) {
6739 buf << "14=" << Value14_Get(parent) << soh;
6740 }
6741 if (Value15_PresentQ(parent)) {
6742 buf << "15=" << Value15_Get(parent) << soh;
6743 }
6744 if (Value16_PresentQ(parent)) {
6745 buf << "16=" << Value16_Get(parent) << soh;
6746 }
6747 if (Value17_PresentQ(parent)) {
6748 buf << "17=" << Value17_Get(parent) << soh;
6749 }
6750 if (Value18_PresentQ(parent)) {
6751 buf << "18=" << Value18_Get(parent) << soh;
6752 }
6753 if (Value19_PresentQ(parent)) {
6754 buf << "19=" << Value19_Get(parent) << soh;
6755 }
6756 if (Value20_PresentQ(parent)) {
6757 buf << "20=" << Value20_Get(parent) << soh;
6758 }
6759 if (Value21_PresentQ(parent)) {
6760 buf << "21=" << Value21_Get(parent) << soh;
6761 }
6762 if (Value22_PresentQ(parent)) {
6763 buf << "22=" << Value22_Get(parent) << soh;
6764 }
6765 if (Value23_PresentQ(parent)) {
6766 buf << "23=" << Value23_Get(parent) << soh;
6767 }
6768 if (Value24_PresentQ(parent)) {
6769 buf << "24=" << Value24_Get(parent) << soh;
6770 }
6771 if (Value25_PresentQ(parent)) {
6772 buf << "25=" << Value25_Get(parent) << soh;
6773 }
6774 if (Value26_PresentQ(parent)) {
6775 buf << "26=" << Value26_Get(parent) << soh;
6776 }
6777 if (Value27_PresentQ(parent)) {
6778 buf << "27=" << Value27_Get(parent) << soh;
6779 }
6780 if (Value28_PresentQ(parent)) {
6781 buf << "28=" << Value28_Get(parent) << soh;
6782 }
6783 if (Value29_PresentQ(parent)) {
6784 buf << "29=" << Value29_Get(parent) << soh;
6785 }
6786 if (Value30_PresentQ(parent)) {
6787 buf << "30=" << Value30_Get(parent) << soh;
6788 }
6789 if (Value31_PresentQ(parent)) {
6790 buf << "31=" << Value31_Get(parent) << soh;
6791 }
6792 if (Value32_PresentQ(parent)) {
6793 buf << "32=" << Value32_Get(parent) << soh;
6794 }
6795 if (Value33_PresentQ(parent)) {
6796 buf << "33=" << Value33_Get(parent) << soh;
6797 }
6798 if (Value34_PresentQ(parent)) {
6799 buf << "34=" << Value34_Get(parent) << soh;
6800 }
6801 if (Value35_PresentQ(parent)) {
6802 buf << "35=" << Value35_Get(parent) << soh;
6803 }
6804 if (Value36_PresentQ(parent)) {
6805 buf << "36=" << Value36_Get(parent) << soh;
6806 }
6807 if (Value37_PresentQ(parent)) {
6808 buf << "37=" << Value37_Get(parent) << soh;
6809 }
6810 if (Value38_PresentQ(parent)) {
6811 buf << "38=" << Value38_Get(parent) << soh;
6812 }
6813 if (Value39_PresentQ(parent)) {
6814 buf << "39=" << Value39_Get(parent) << soh;
6815 }
6816 if (Value40_PresentQ(parent)) {
6817 buf << "40=" << Value40_Get(parent) << soh;
6818 }
6819 if (Value41_PresentQ(parent)) {
6820 buf << "41=" << Value41_Get(parent) << soh;
6821 }
6822 if (Value42_PresentQ(parent)) {
6823 buf << "42=" << Value42_Get(parent) << soh;
6824 }
6825 if (Value43_PresentQ(parent)) {
6826 buf << "43=" << Value43_Get(parent) << soh;
6827 }
6828 if (Value44_PresentQ(parent)) {
6829 buf << "44=" << Value44_Get(parent) << soh;
6830 }
6831 if (Value45_PresentQ(parent)) {
6832 buf << "45=" << Value45_Get(parent) << soh;
6833 }
6834 if (Value46_PresentQ(parent)) {
6835 buf << "46=" << Value46_Get(parent) << soh;
6836 }
6837 if (Value47_PresentQ(parent)) {
6838 buf << "47=" << Value47_Get(parent) << soh;
6839 }
6840 if (Value48_PresentQ(parent)) {
6841 buf << "48=" << Value48_Get(parent) << soh;
6842 }
6843 if (Value49_PresentQ(parent)) {
6844 buf << "49=" << Value49_Get(parent) << soh;
6845 }
6846 if (Value50_PresentQ(parent)) {
6847 buf << "50=" << Value50_Get(parent) << soh;
6848 }
6849 if (Value51_PresentQ(parent)) {
6850 buf << "51=" << Value51_Get(parent) << soh;
6851 }
6852 if (Value52_PresentQ(parent)) {
6853 buf << "52=" << Value52_Get(parent) << soh;
6854 }
6855 if (Value53_PresentQ(parent)) {
6856 buf << "53=" << Value53_Get(parent) << soh;
6857 }
6858 if (Value54_PresentQ(parent)) {
6859 buf << "54=" << Value54_Get(parent) << soh;
6860 }
6861 if (Value55_PresentQ(parent)) {
6862 buf << "55=" << Value55_Get(parent) << soh;
6863 }
6864 if (Value56_PresentQ(parent)) {
6865 buf << "56=" << Value56_Get(parent) << soh;
6866 }
6867 if (Value57_PresentQ(parent)) {
6868 buf << "57=" << Value57_Get(parent) << soh;
6869 }
6870 if (Value58_PresentQ(parent)) {
6871 buf << "58=" << Value58_Get(parent) << soh;
6872 }
6873 if (Value59_PresentQ(parent)) {
6874 buf << "59=" << Value59_Get(parent) << soh;
6875 }
6876 if (Value60_PresentQ(parent)) {
6877 buf << "60=" << Value60_Get(parent) << soh;
6878 }
6879 if (Value61_PresentQ(parent)) {
6880 buf << "61=" << Value61_Get(parent) << soh;
6881 }
6882 if (Value62_PresentQ(parent)) {
6883 buf << "62=" << Value62_Get(parent) << soh;
6884 }
6885 if (Value63_PresentQ(parent)) {
6886 buf << "63=" << Value63_Get(parent) << soh;
6887 }
6888}
6889
6890// --- fasttest.OptSgmSeq..ReadFieldMaybe
6891bool fasttest::OptSgmSeq_ReadFieldMaybe(fasttest::OptSgmSeq& parent, algo::strptr field, algo::strptr strval) {
6892 bool retval = true;
6893 fasttest::FieldId field_id;
6894 (void)value_SetStrptrMaybe(field_id,field);
6895 switch(field_id) {
6896 case fasttest_FieldId_Value: {
6897 retval = u32_ReadStrptrMaybe(parent.Value, strval);
6898 break;
6899 }
6900 default: break;
6901 }
6902 if (!retval) {
6903 algo_lib::AppendErrtext("attr",field);
6904 }
6905 return retval;
6906}
6907
6908// --- fasttest.OptSgmSeq..ReadStrptrMaybe
6909// Read fields of fasttest::OptSgmSeq from an ascii string.
6910// The format of the string is an ssim Tuple
6911bool fasttest::OptSgmSeq_ReadStrptrMaybe(fasttest::OptSgmSeq &parent, algo::strptr in_str) {
6912 bool retval = true;
6913 retval = algo::StripTypeTag(in_str, "fasttest.OptSgmSeq");
6914 ind_beg(algo::Attr_curs, attr, in_str) {
6915 retval = retval && OptSgmSeq_ReadFieldMaybe(parent, attr.name, attr.value);
6916 }ind_end;
6917 return retval;
6918}
6919
6920// --- fasttest.OptSgmSeq..Print
6921// print string representation of ROW to string STR
6922// cfmt:fasttest.OptSgmSeq.String printfmt:Tuple
6923void fasttest::OptSgmSeq_Print(fasttest::OptSgmSeq& row, algo::cstring& str) {
6924 algo::tempstr temp;
6925 str << "fasttest.OptSgmSeq";
6926
6927 u32_Print(row.Value, temp);
6928 PrintAttrSpaceReset(str,"Value", temp);
6929}
6930
6931// --- fasttest.OptSgmSeq..FastEncode
6932void fasttest::OptSgmSeq_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::OptSgmSeq& parent) {
6933 int index = ary_N(buf);
6934 u64 pmap(0);
6935 // Value unsigned default mandatory
6936 if (parent.Value != 1) {
6937 lib_fast::EncodeUnsigned(buf,parent.Value,false);
6938 lib_fast::SetPmapBit(pmap,0);
6939 }
6940 lib_fast::InsertPmap(buf,index,pmap);
6941 (void)state;//only to avoid -Wunused-parameter
6942}
6943
6944// --- fasttest.OptSgmSeq..FastDecode
6945bool fasttest::OptSgmSeq_FastDecode(algo::memptr& from, FastState& state, fasttest::OptSgmSeq& parent) {
6946 bool ok = true;
6947 u64 pmap;
6948 ok = lib_fast::DecodePmap(from,pmap);
6949 if (!ok) {
6950 state.error << "fasttest.OptSgmSeq: bad pmap" << eol;
6951 }
6952 // Value unsigned default mandatory
6953 if (ok) {
6954 bool prs = lib_fast::GetPmapBit(pmap,0);
6955 if (prs) {
6956 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
6957 if (!ok) {
6958 state.error << "fasttest.OptSgmSeq.Value: bad Unsigned" << eol;
6959 }
6960 } else {
6961 parent.Value = 1;
6962 }
6963 }
6964 return ok;
6965}
6966
6967// --- fasttest.OptSgmSeq..FixEncode
6968void fasttest::OptSgmSeq_FixEncode(cstring& buf, fasttest::OptSgmSeq& parent, char soh) {
6969 buf << "2=" << parent.Value << soh;
6970}
6971
6972// --- fasttest.OptTrvSeq..ReadFieldMaybe
6973bool fasttest::OptTrvSeq_ReadFieldMaybe(fasttest::OptTrvSeq& parent, algo::strptr field, algo::strptr strval) {
6974 bool retval = true;
6975 fasttest::FieldId field_id;
6976 (void)value_SetStrptrMaybe(field_id,field);
6977 switch(field_id) {
6978 case fasttest_FieldId_Value: {
6979 retval = u32_ReadStrptrMaybe(parent.Value, strval);
6980 break;
6981 }
6982 default: break;
6983 }
6984 if (!retval) {
6985 algo_lib::AppendErrtext("attr",field);
6986 }
6987 return retval;
6988}
6989
6990// --- fasttest.OptTrvSeq..ReadStrptrMaybe
6991// Read fields of fasttest::OptTrvSeq from an ascii string.
6992// The format of the string is an ssim Tuple
6993bool fasttest::OptTrvSeq_ReadStrptrMaybe(fasttest::OptTrvSeq &parent, algo::strptr in_str) {
6994 bool retval = true;
6995 retval = algo::StripTypeTag(in_str, "fasttest.OptTrvSeq");
6996 ind_beg(algo::Attr_curs, attr, in_str) {
6997 retval = retval && OptTrvSeq_ReadFieldMaybe(parent, attr.name, attr.value);
6998 }ind_end;
6999 return retval;
7000}
7001
7002// --- fasttest.OptTrvSeq..Print
7003// print string representation of ROW to string STR
7004// cfmt:fasttest.OptTrvSeq.String printfmt:Tuple
7005void fasttest::OptTrvSeq_Print(fasttest::OptTrvSeq& row, algo::cstring& str) {
7006 algo::tempstr temp;
7007 str << "fasttest.OptTrvSeq";
7008
7009 u32_Print(row.Value, temp);
7010 PrintAttrSpaceReset(str,"Value", temp);
7011}
7012
7013// --- fasttest.OptTrvSeq..FastEncode
7014void fasttest::OptTrvSeq_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::OptTrvSeq& parent) {
7015 // Value unsigned none mandatory
7016 lib_fast::EncodeUnsigned(buf,parent.Value,false);
7017 (void)state;//only to avoid -Wunused-parameter
7018}
7019
7020// --- fasttest.OptTrvSeq..FastDecode
7021bool fasttest::OptTrvSeq_FastDecode(algo::memptr& from, FastState& state, fasttest::OptTrvSeq& parent) {
7022 bool ok = true;
7023 // Value unsigned none mandatory
7024 if (ok) {
7025 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
7026 if (!ok) {
7027 state.error << "fasttest.OptTrvSeq.Value: bad Unsigned" << eol;
7028 }
7029 }
7030 return ok;
7031}
7032
7033// --- fasttest.OptTrvSeq..FixEncode
7034void fasttest::OptTrvSeq_FixEncode(cstring& buf, fasttest::OptTrvSeq& parent, char soh) {
7035 buf << "2=" << parent.Value << soh;
7036}
7037
7038// --- fasttest.Reset.base.CopyOut
7039// Copy fields out of row
7040void fasttest::parent_CopyOut(fasttest::Reset &row, fasttest::TemplateHeader &out) {
7041 // length: field value is computed
7042 // id: field value is computed
7043 (void)row;//only to avoid -Wunused-parameter
7044 (void)out;//only to avoid -Wunused-parameter
7045}
7046
7047// --- fasttest.Reset..ReadFieldMaybe
7048bool fasttest::Reset_ReadFieldMaybe(fasttest::Reset& parent, algo::strptr field, algo::strptr strval) {
7049 bool retval = true;
7050 fasttest::FieldId field_id;
7051 (void)value_SetStrptrMaybe(field_id,field);
7052 switch(field_id) {
7053 case fasttest_FieldId_base: {
7054 retval = false;
7055 break;
7056 }
7057 case fasttest_FieldId_length: {
7058 retval = false;
7059 break;
7060 }
7061 case fasttest_FieldId_id: {
7062 retval = false;
7063 break;
7064 }
7065 default: break;
7066 }
7067 if (!retval) {
7068 algo_lib::AppendErrtext("attr",field);
7069 }
7070 (void)parent;//only to avoid -Wunused-parameter
7071 (void)strval;//only to avoid -Wunused-parameter
7072 return retval;
7073}
7074
7075// --- fasttest.Reset..ReadStrptrMaybe
7076// Read fields of fasttest::Reset from an ascii string.
7077// The format of the string is an ssim Tuple
7078bool fasttest::Reset_ReadStrptrMaybe(fasttest::Reset &parent, algo::strptr in_str) {
7079 bool retval = true;
7080 retval = algo::StripTypeTag(in_str, "fasttest.Reset");
7081 ind_beg(algo::Attr_curs, attr, in_str) {
7082 retval = retval && Reset_ReadFieldMaybe(parent, attr.name, attr.value);
7083 }ind_end;
7084 return retval;
7085}
7086
7087// --- fasttest.Reset..Print
7088// print string representation of ROW to string STR
7089// cfmt:fasttest.Reset.String printfmt:Tuple
7090void fasttest::Reset_Print(fasttest::Reset& row, algo::cstring& str) {
7091 algo::tempstr temp;
7092 str << "fasttest.Reset";
7093 (void)row;//only to avoid -Wunused-parameter
7094}
7095
7096// --- fasttest.Reset..FastEncode
7097void fasttest::Reset_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::Reset& parent) {
7098 int index = ary_N(buf);
7099 u64 pmap(0);
7100 if (!tid_AssignedQ(state) || parent.id != state.tid) {
7101 lib_fast::EncodeUnsigned(buf,parent.id,false);
7102 lib_fast::SetPmapBit(pmap,0);
7103 }
7104 tid_SetAssigned(state);
7105 state.tid = parent.id;
7106 lib_fast::InsertPmap(buf,index,pmap);
7107}
7108
7109// --- fasttest.Reset..FastDecode
7110bool fasttest::Reset_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::Reset& parent) {
7111 bool ok = true;
7112 (void)from;//only to avoid -Wunused-parameter
7113 (void)pmap;//only to avoid -Wunused-parameter
7114 (void)state;//only to avoid -Wunused-parameter
7115 (void)parent;//only to avoid -Wunused-parameter
7116 return ok;
7117}
7118
7119// --- fasttest.Reset..FixEncode
7120void fasttest::Reset_FixEncode(cstring& buf, fasttest::Reset& parent, char soh) {
7121 (void)buf;//only to avoid -Wunused-parameter
7122 (void)parent;//only to avoid -Wunused-parameter
7123 (void)soh;//only to avoid -Wunused-parameter
7124}
7125
7126// --- fasttest.SampleEnumConst.base.CopyOut
7127// Copy fields out of row
7128void fasttest::parent_CopyOut(fasttest::SampleEnumConst &row, fasttest::TemplateHeader &out) {
7129 // length: field value is computed
7130 // id: field value is computed
7131 (void)row;//only to avoid -Wunused-parameter
7132 (void)out;//only to avoid -Wunused-parameter
7133}
7134
7135// --- fasttest.SampleEnumConst..ReadFieldMaybe
7136bool fasttest::SampleEnumConst_ReadFieldMaybe(fasttest::SampleEnumConst& parent, algo::strptr field, algo::strptr strval) {
7137 bool retval = true;
7138 fasttest::FieldId field_id;
7139 (void)value_SetStrptrMaybe(field_id,field);
7140 switch(field_id) {
7141 case fasttest_FieldId_base: {
7142 retval = false;
7143 break;
7144 }
7145 case fasttest_FieldId_length: {
7146 retval = false;
7147 break;
7148 }
7149 case fasttest_FieldId_id: {
7150 retval = false;
7151 break;
7152 }
7153 case fasttest_FieldId_Value: {
7154 retval = true;
7155 break;
7156 }
7157 default: break;
7158 }
7159 if (!retval) {
7160 algo_lib::AppendErrtext("attr",field);
7161 }
7162 (void)parent;//only to avoid -Wunused-parameter
7163 (void)strval;//only to avoid -Wunused-parameter
7164 return retval;
7165}
7166
7167// --- fasttest.SampleEnumConst..ReadStrptrMaybe
7168// Read fields of fasttest::SampleEnumConst from an ascii string.
7169// The format of the string is an ssim Tuple
7170bool fasttest::SampleEnumConst_ReadStrptrMaybe(fasttest::SampleEnumConst &parent, algo::strptr in_str) {
7171 bool retval = true;
7172 retval = algo::StripTypeTag(in_str, "fasttest.SampleEnumConst");
7173 ind_beg(algo::Attr_curs, attr, in_str) {
7174 retval = retval && SampleEnumConst_ReadFieldMaybe(parent, attr.name, attr.value);
7175 }ind_end;
7176 return retval;
7177}
7178
7179// --- fasttest.SampleEnumConst..Print
7180// print string representation of ROW to string STR
7181// cfmt:fasttest.SampleEnumConst.String printfmt:Tuple
7182void fasttest::SampleEnumConst_Print(fasttest::SampleEnumConst& row, algo::cstring& str) {
7183 algo::tempstr temp;
7184 str << "fasttest.SampleEnumConst";
7185
7186 fasttest::SampleEnum_Print(Value_Get(row), temp);
7187 PrintAttrSpaceReset(str,"Value", temp);
7188}
7189
7190// --- fasttest.SampleEnumConst..FastEncode
7191void fasttest::SampleEnumConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleEnumConst& parent) {
7192 int index = ary_N(buf);
7193 u64 pmap(0);
7194 if (!tid_AssignedQ(state) || parent.id != state.tid) {
7195 lib_fast::EncodeUnsigned(buf,parent.id,false);
7196 lib_fast::SetPmapBit(pmap,0);
7197 }
7198 tid_SetAssigned(state);
7199 state.tid = parent.id;
7200 // Value type constant mandatory
7201 lib_fast::InsertPmap(buf,index,pmap);
7202}
7203
7204// --- fasttest.SampleEnumConst..FastDecode
7205bool fasttest::SampleEnumConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleEnumConst& parent) {
7206 bool ok = true;
7207 // Value type constant mandatory
7208 if (ok) {
7209 }
7210 (void)from;//only to avoid -Wunused-parameter
7211 (void)pmap;//only to avoid -Wunused-parameter
7212 (void)state;//only to avoid -Wunused-parameter
7213 (void)parent;//only to avoid -Wunused-parameter
7214 return ok;
7215}
7216
7217// --- fasttest.SampleEnumConst..FixEncode
7218void fasttest::SampleEnumConst_FixEncode(cstring& buf, fasttest::SampleEnumConst& parent, char soh) {
7219 buf << "1=" << Value_Get(parent) << soh;
7220}
7221
7222// --- fasttest.SampleEnumCopy.base.CopyOut
7223// Copy fields out of row
7224void fasttest::parent_CopyOut(fasttest::SampleEnumCopy &row, fasttest::TemplateHeader &out) {
7225 // length: field value is computed
7226 // id: field value is computed
7227 (void)row;//only to avoid -Wunused-parameter
7228 (void)out;//only to avoid -Wunused-parameter
7229}
7230
7231// --- fasttest.SampleEnumCopy..ReadFieldMaybe
7232bool fasttest::SampleEnumCopy_ReadFieldMaybe(fasttest::SampleEnumCopy& parent, algo::strptr field, algo::strptr strval) {
7233 bool retval = true;
7234 fasttest::FieldId field_id;
7235 (void)value_SetStrptrMaybe(field_id,field);
7236 switch(field_id) {
7237 case fasttest_FieldId_base: {
7238 retval = false;
7239 break;
7240 }
7241 case fasttest_FieldId_length: {
7242 retval = false;
7243 break;
7244 }
7245 case fasttest_FieldId_id: {
7246 retval = false;
7247 break;
7248 }
7249 case fasttest_FieldId_Value147: {
7250 retval = fasttest::SampleEnum_ReadStrptrMaybe(parent.Value147, strval);
7251 break;
7252 }
7253 default: break;
7254 }
7255 if (!retval) {
7256 algo_lib::AppendErrtext("attr",field);
7257 }
7258 return retval;
7259}
7260
7261// --- fasttest.SampleEnumCopy..ReadStrptrMaybe
7262// Read fields of fasttest::SampleEnumCopy from an ascii string.
7263// The format of the string is an ssim Tuple
7264bool fasttest::SampleEnumCopy_ReadStrptrMaybe(fasttest::SampleEnumCopy &parent, algo::strptr in_str) {
7265 bool retval = true;
7266 retval = algo::StripTypeTag(in_str, "fasttest.SampleEnumCopy");
7267 ind_beg(algo::Attr_curs, attr, in_str) {
7268 retval = retval && SampleEnumCopy_ReadFieldMaybe(parent, attr.name, attr.value);
7269 }ind_end;
7270 return retval;
7271}
7272
7273// --- fasttest.SampleEnumCopy..Print
7274// print string representation of ROW to string STR
7275// cfmt:fasttest.SampleEnumCopy.String printfmt:Tuple
7276void fasttest::SampleEnumCopy_Print(fasttest::SampleEnumCopy& row, algo::cstring& str) {
7277 algo::tempstr temp;
7278 str << "fasttest.SampleEnumCopy";
7279
7280 fasttest::SampleEnum_Print(row.Value147, temp);
7281 PrintAttrSpaceReset(str,"Value147", temp);
7282}
7283
7284// --- fasttest.SampleEnumCopy..FastEncode
7285void fasttest::SampleEnumCopy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleEnumCopy& parent) {
7286 int index = ary_N(buf);
7287 u64 pmap(0);
7288 if (!tid_AssignedQ(state) || parent.id != state.tid) {
7289 lib_fast::EncodeUnsigned(buf,parent.id,false);
7290 lib_fast::SetPmapBit(pmap,0);
7291 }
7292 tid_SetAssigned(state);
7293 state.tid = parent.id;
7294 // Value147 type copy mandatory
7295 if (Value147_AssignedQ(state) ? parent.Value147.value != state.Value147.value : parent.Value147.value != 0) {
7296 lib_fast::EncodeUnsigned(buf,parent.Value147.value,false);
7297 lib_fast::SetPmapBit(pmap,1);
7298 }
7299 state.Value147.value = parent.Value147.value;
7300 Value147_SetAssigned(state);
7301 lib_fast::InsertPmap(buf,index,pmap);
7302}
7303
7304// --- fasttest.SampleEnumCopy..FastDecode
7305bool fasttest::SampleEnumCopy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleEnumCopy& parent) {
7306 bool ok = true;
7307 // Value147 type copy mandatory
7308 if (ok) {
7309 bool prs = lib_fast::GetPmapBit(pmap,1);
7310 if (prs) {
7311 ok = lib_fast::DecodeUnsigned(from,parent.Value147.value,false);
7312 if (!ok) {
7313 state.error << "fasttest.SampleEnumCopy.Value147: bad Unsigned" << eol;
7314 }
7315 } else if (Value147_AssignedQ(state)) {
7316 parent.Value147.value = state.Value147.value;
7317 } else {
7318 parent.Value147.value = 0;
7319 }
7320 Value147_SetAssigned(state);
7321 state.Value147.value = parent.Value147.value;
7322 }
7323 return ok;
7324}
7325
7326// --- fasttest.SampleEnumCopy..FixEncode
7327void fasttest::SampleEnumCopy_FixEncode(cstring& buf, fasttest::SampleEnumCopy& parent, char soh) {
7328 buf << "1=" << parent.Value147 << soh;
7329}
7330
7331// --- fasttest.SampleEnumDefault.base.CopyOut
7332// Copy fields out of row
7333void fasttest::parent_CopyOut(fasttest::SampleEnumDefault &row, fasttest::TemplateHeader &out) {
7334 // length: field value is computed
7335 // id: field value is computed
7336 (void)row;//only to avoid -Wunused-parameter
7337 (void)out;//only to avoid -Wunused-parameter
7338}
7339
7340// --- fasttest.SampleEnumDefault..ReadFieldMaybe
7341bool fasttest::SampleEnumDefault_ReadFieldMaybe(fasttest::SampleEnumDefault& parent, algo::strptr field, algo::strptr strval) {
7342 bool retval = true;
7343 fasttest::FieldId field_id;
7344 (void)value_SetStrptrMaybe(field_id,field);
7345 switch(field_id) {
7346 case fasttest_FieldId_base: {
7347 retval = false;
7348 break;
7349 }
7350 case fasttest_FieldId_length: {
7351 retval = false;
7352 break;
7353 }
7354 case fasttest_FieldId_id: {
7355 retval = false;
7356 break;
7357 }
7358 case fasttest_FieldId_Value: {
7359 retval = fasttest::SampleEnum_ReadStrptrMaybe(parent.Value, strval);
7360 break;
7361 }
7362 default: break;
7363 }
7364 if (!retval) {
7365 algo_lib::AppendErrtext("attr",field);
7366 }
7367 return retval;
7368}
7369
7370// --- fasttest.SampleEnumDefault..ReadStrptrMaybe
7371// Read fields of fasttest::SampleEnumDefault from an ascii string.
7372// The format of the string is an ssim Tuple
7373bool fasttest::SampleEnumDefault_ReadStrptrMaybe(fasttest::SampleEnumDefault &parent, algo::strptr in_str) {
7374 bool retval = true;
7375 retval = algo::StripTypeTag(in_str, "fasttest.SampleEnumDefault");
7376 ind_beg(algo::Attr_curs, attr, in_str) {
7377 retval = retval && SampleEnumDefault_ReadFieldMaybe(parent, attr.name, attr.value);
7378 }ind_end;
7379 return retval;
7380}
7381
7382// --- fasttest.SampleEnumDefault..Print
7383// print string representation of ROW to string STR
7384// cfmt:fasttest.SampleEnumDefault.String printfmt:Tuple
7385void fasttest::SampleEnumDefault_Print(fasttest::SampleEnumDefault& row, algo::cstring& str) {
7386 algo::tempstr temp;
7387 str << "fasttest.SampleEnumDefault";
7388
7389 fasttest::SampleEnum_Print(row.Value, temp);
7390 PrintAttrSpaceReset(str,"Value", temp);
7391}
7392
7393// --- fasttest.SampleEnumDefault..FastEncode
7394void fasttest::SampleEnumDefault_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleEnumDefault& parent) {
7395 int index = ary_N(buf);
7396 u64 pmap(0);
7397 if (!tid_AssignedQ(state) || parent.id != state.tid) {
7398 lib_fast::EncodeUnsigned(buf,parent.id,false);
7399 lib_fast::SetPmapBit(pmap,0);
7400 }
7401 tid_SetAssigned(state);
7402 state.tid = parent.id;
7403 // Value type default mandatory
7404 if (parent.Value.value != 2) {
7405 lib_fast::EncodeUnsigned(buf,parent.Value.value,false);
7406 lib_fast::SetPmapBit(pmap,1);
7407 }
7408 lib_fast::InsertPmap(buf,index,pmap);
7409}
7410
7411// --- fasttest.SampleEnumDefault..FastDecode
7412bool fasttest::SampleEnumDefault_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleEnumDefault& parent) {
7413 bool ok = true;
7414 // Value type default mandatory
7415 if (ok) {
7416 bool prs = lib_fast::GetPmapBit(pmap,1);
7417 if (prs) {
7418 ok = lib_fast::DecodeUnsigned(from,parent.Value.value,false);
7419 if (!ok) {
7420 state.error << "fasttest.SampleEnumDefault.Value: bad Unsigned" << eol;
7421 }
7422 } else {
7423 parent.Value.value = 2;
7424 }
7425 }
7426 return ok;
7427}
7428
7429// --- fasttest.SampleEnumDefault..FixEncode
7430void fasttest::SampleEnumDefault_FixEncode(cstring& buf, fasttest::SampleEnumDefault& parent, char soh) {
7431 buf << "1=" << parent.Value << soh;
7432}
7433
7434// --- fasttest.SampleSetConst.base.CopyOut
7435// Copy fields out of row
7436void fasttest::parent_CopyOut(fasttest::SampleSetConst &row, fasttest::TemplateHeader &out) {
7437 // length: field value is computed
7438 // id: field value is computed
7439 (void)row;//only to avoid -Wunused-parameter
7440 (void)out;//only to avoid -Wunused-parameter
7441}
7442
7443// --- fasttest.SampleSetConst..ReadFieldMaybe
7444bool fasttest::SampleSetConst_ReadFieldMaybe(fasttest::SampleSetConst& parent, algo::strptr field, algo::strptr strval) {
7445 bool retval = true;
7446 fasttest::FieldId field_id;
7447 (void)value_SetStrptrMaybe(field_id,field);
7448 switch(field_id) {
7449 case fasttest_FieldId_base: {
7450 retval = false;
7451 break;
7452 }
7453 case fasttest_FieldId_length: {
7454 retval = false;
7455 break;
7456 }
7457 case fasttest_FieldId_id: {
7458 retval = false;
7459 break;
7460 }
7461 case fasttest_FieldId_Value: {
7462 retval = true;
7463 break;
7464 }
7465 default: break;
7466 }
7467 if (!retval) {
7468 algo_lib::AppendErrtext("attr",field);
7469 }
7470 (void)parent;//only to avoid -Wunused-parameter
7471 (void)strval;//only to avoid -Wunused-parameter
7472 return retval;
7473}
7474
7475// --- fasttest.SampleSetConst..ReadStrptrMaybe
7476// Read fields of fasttest::SampleSetConst from an ascii string.
7477// The format of the string is an ssim Tuple
7478bool fasttest::SampleSetConst_ReadStrptrMaybe(fasttest::SampleSetConst &parent, algo::strptr in_str) {
7479 bool retval = true;
7480 retval = algo::StripTypeTag(in_str, "fasttest.SampleSetConst");
7481 ind_beg(algo::Attr_curs, attr, in_str) {
7482 retval = retval && SampleSetConst_ReadFieldMaybe(parent, attr.name, attr.value);
7483 }ind_end;
7484 return retval;
7485}
7486
7487// --- fasttest.SampleSetConst..Print
7488// print string representation of ROW to string STR
7489// cfmt:fasttest.SampleSetConst.String printfmt:Tuple
7490void fasttest::SampleSetConst_Print(fasttest::SampleSetConst& row, algo::cstring& str) {
7491 algo::tempstr temp;
7492 str << "fasttest.SampleSetConst";
7493
7494 fasttest::SampleSet_Print(Value_Get(row), temp);
7495 PrintAttrSpaceReset(str,"Value", temp);
7496}
7497
7498// --- fasttest.SampleSetConst..FastEncode
7499void fasttest::SampleSetConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleSetConst& parent) {
7500 int index = ary_N(buf);
7501 u64 pmap(0);
7502 if (!tid_AssignedQ(state) || parent.id != state.tid) {
7503 lib_fast::EncodeUnsigned(buf,parent.id,false);
7504 lib_fast::SetPmapBit(pmap,0);
7505 }
7506 tid_SetAssigned(state);
7507 state.tid = parent.id;
7508 // Value type constant mandatory
7509 lib_fast::InsertPmap(buf,index,pmap);
7510}
7511
7512// --- fasttest.SampleSetConst..FastDecode
7513bool fasttest::SampleSetConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleSetConst& parent) {
7514 bool ok = true;
7515 // Value type constant mandatory
7516 if (ok) {
7517 }
7518 (void)from;//only to avoid -Wunused-parameter
7519 (void)pmap;//only to avoid -Wunused-parameter
7520 (void)state;//only to avoid -Wunused-parameter
7521 (void)parent;//only to avoid -Wunused-parameter
7522 return ok;
7523}
7524
7525// --- fasttest.SampleSetConst..FixEncode
7526void fasttest::SampleSetConst_FixEncode(cstring& buf, fasttest::SampleSetConst& parent, char soh) {
7527 buf << "1=" << Value_Get(parent) << soh;
7528}
7529
7530// --- fasttest.SampleSetCopy.base.CopyOut
7531// Copy fields out of row
7532void fasttest::parent_CopyOut(fasttest::SampleSetCopy &row, fasttest::TemplateHeader &out) {
7533 // length: field value is computed
7534 // id: field value is computed
7535 (void)row;//only to avoid -Wunused-parameter
7536 (void)out;//only to avoid -Wunused-parameter
7537}
7538
7539// --- fasttest.SampleSetCopy..ReadFieldMaybe
7540bool fasttest::SampleSetCopy_ReadFieldMaybe(fasttest::SampleSetCopy& parent, algo::strptr field, algo::strptr strval) {
7541 bool retval = true;
7542 fasttest::FieldId field_id;
7543 (void)value_SetStrptrMaybe(field_id,field);
7544 switch(field_id) {
7545 case fasttest_FieldId_base: {
7546 retval = false;
7547 break;
7548 }
7549 case fasttest_FieldId_length: {
7550 retval = false;
7551 break;
7552 }
7553 case fasttest_FieldId_id: {
7554 retval = false;
7555 break;
7556 }
7557 case fasttest_FieldId_Value150: {
7558 retval = fasttest::SampleSet_ReadStrptrMaybe(parent.Value150, strval);
7559 break;
7560 }
7561 default: break;
7562 }
7563 if (!retval) {
7564 algo_lib::AppendErrtext("attr",field);
7565 }
7566 return retval;
7567}
7568
7569// --- fasttest.SampleSetCopy..ReadStrptrMaybe
7570// Read fields of fasttest::SampleSetCopy from an ascii string.
7571// The format of the string is an ssim Tuple
7572bool fasttest::SampleSetCopy_ReadStrptrMaybe(fasttest::SampleSetCopy &parent, algo::strptr in_str) {
7573 bool retval = true;
7574 retval = algo::StripTypeTag(in_str, "fasttest.SampleSetCopy");
7575 ind_beg(algo::Attr_curs, attr, in_str) {
7576 retval = retval && SampleSetCopy_ReadFieldMaybe(parent, attr.name, attr.value);
7577 }ind_end;
7578 return retval;
7579}
7580
7581// --- fasttest.SampleSetCopy..Print
7582// print string representation of ROW to string STR
7583// cfmt:fasttest.SampleSetCopy.String printfmt:Tuple
7584void fasttest::SampleSetCopy_Print(fasttest::SampleSetCopy& row, algo::cstring& str) {
7585 algo::tempstr temp;
7586 str << "fasttest.SampleSetCopy";
7587
7588 fasttest::SampleSet_Print(row.Value150, temp);
7589 PrintAttrSpaceReset(str,"Value150", temp);
7590}
7591
7592// --- fasttest.SampleSetCopy..FastEncode
7593void fasttest::SampleSetCopy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleSetCopy& parent) {
7594 int index = ary_N(buf);
7595 u64 pmap(0);
7596 if (!tid_AssignedQ(state) || parent.id != state.tid) {
7597 lib_fast::EncodeUnsigned(buf,parent.id,false);
7598 lib_fast::SetPmapBit(pmap,0);
7599 }
7600 tid_SetAssigned(state);
7601 state.tid = parent.id;
7602 // Value150 type copy mandatory
7603 if (Value150_AssignedQ(state) ? parent.Value150.value != state.Value150.value : parent.Value150.value != 2) {
7604 lib_fast::EncodeUnsigned(buf,parent.Value150.value,false);
7605 lib_fast::SetPmapBit(pmap,1);
7606 }
7607 state.Value150.value = parent.Value150.value;
7608 Value150_SetAssigned(state);
7609 lib_fast::InsertPmap(buf,index,pmap);
7610}
7611
7612// --- fasttest.SampleSetCopy..FastDecode
7613bool fasttest::SampleSetCopy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleSetCopy& parent) {
7614 bool ok = true;
7615 // Value150 type copy mandatory
7616 if (ok) {
7617 bool prs = lib_fast::GetPmapBit(pmap,1);
7618 if (prs) {
7619 ok = lib_fast::DecodeUnsigned(from,parent.Value150.value,false);
7620 if (!ok) {
7621 state.error << "fasttest.SampleSetCopy.Value150: bad Unsigned" << eol;
7622 }
7623 } else if (Value150_AssignedQ(state)) {
7624 parent.Value150.value = state.Value150.value;
7625 } else {
7626 parent.Value150.value = 2;
7627 }
7628 Value150_SetAssigned(state);
7629 state.Value150.value = parent.Value150.value;
7630 }
7631 return ok;
7632}
7633
7634// --- fasttest.SampleSetCopy..FixEncode
7635void fasttest::SampleSetCopy_FixEncode(cstring& buf, fasttest::SampleSetCopy& parent, char soh) {
7636 buf << "1=" << parent.Value150 << soh;
7637}
7638
7639// --- fasttest.SampleSetDefault.base.CopyOut
7640// Copy fields out of row
7641void fasttest::parent_CopyOut(fasttest::SampleSetDefault &row, fasttest::TemplateHeader &out) {
7642 // length: field value is computed
7643 // id: field value is computed
7644 (void)row;//only to avoid -Wunused-parameter
7645 (void)out;//only to avoid -Wunused-parameter
7646}
7647
7648// --- fasttest.SampleSetDefault..ReadFieldMaybe
7649bool fasttest::SampleSetDefault_ReadFieldMaybe(fasttest::SampleSetDefault& parent, algo::strptr field, algo::strptr strval) {
7650 bool retval = true;
7651 fasttest::FieldId field_id;
7652 (void)value_SetStrptrMaybe(field_id,field);
7653 switch(field_id) {
7654 case fasttest_FieldId_base: {
7655 retval = false;
7656 break;
7657 }
7658 case fasttest_FieldId_length: {
7659 retval = false;
7660 break;
7661 }
7662 case fasttest_FieldId_id: {
7663 retval = false;
7664 break;
7665 }
7666 case fasttest_FieldId_Value: {
7667 retval = fasttest::SampleSet_ReadStrptrMaybe(parent.Value, strval);
7668 break;
7669 }
7670 default: break;
7671 }
7672 if (!retval) {
7673 algo_lib::AppendErrtext("attr",field);
7674 }
7675 return retval;
7676}
7677
7678// --- fasttest.SampleSetDefault..ReadStrptrMaybe
7679// Read fields of fasttest::SampleSetDefault from an ascii string.
7680// The format of the string is an ssim Tuple
7681bool fasttest::SampleSetDefault_ReadStrptrMaybe(fasttest::SampleSetDefault &parent, algo::strptr in_str) {
7682 bool retval = true;
7683 retval = algo::StripTypeTag(in_str, "fasttest.SampleSetDefault");
7684 ind_beg(algo::Attr_curs, attr, in_str) {
7685 retval = retval && SampleSetDefault_ReadFieldMaybe(parent, attr.name, attr.value);
7686 }ind_end;
7687 return retval;
7688}
7689
7690// --- fasttest.SampleSetDefault..Print
7691// print string representation of ROW to string STR
7692// cfmt:fasttest.SampleSetDefault.String printfmt:Tuple
7693void fasttest::SampleSetDefault_Print(fasttest::SampleSetDefault& row, algo::cstring& str) {
7694 algo::tempstr temp;
7695 str << "fasttest.SampleSetDefault";
7696
7697 fasttest::SampleSet_Print(row.Value, temp);
7698 PrintAttrSpaceReset(str,"Value", temp);
7699}
7700
7701// --- fasttest.SampleSetDefault..FastEncode
7702void fasttest::SampleSetDefault_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SampleSetDefault& parent) {
7703 int index = ary_N(buf);
7704 u64 pmap(0);
7705 if (!tid_AssignedQ(state) || parent.id != state.tid) {
7706 lib_fast::EncodeUnsigned(buf,parent.id,false);
7707 lib_fast::SetPmapBit(pmap,0);
7708 }
7709 tid_SetAssigned(state);
7710 state.tid = parent.id;
7711 // Value type default mandatory
7712 if (parent.Value.value != 3) {
7713 lib_fast::EncodeUnsigned(buf,parent.Value.value,false);
7714 lib_fast::SetPmapBit(pmap,1);
7715 }
7716 lib_fast::InsertPmap(buf,index,pmap);
7717}
7718
7719// --- fasttest.SampleSetDefault..FastDecode
7720bool fasttest::SampleSetDefault_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SampleSetDefault& parent) {
7721 bool ok = true;
7722 // Value type default mandatory
7723 if (ok) {
7724 bool prs = lib_fast::GetPmapBit(pmap,1);
7725 if (prs) {
7726 ok = lib_fast::DecodeUnsigned(from,parent.Value.value,false);
7727 if (!ok) {
7728 state.error << "fasttest.SampleSetDefault.Value: bad Unsigned" << eol;
7729 }
7730 } else {
7731 parent.Value.value = 3;
7732 }
7733 }
7734 return ok;
7735}
7736
7737// --- fasttest.SampleSetDefault..FixEncode
7738void fasttest::SampleSetDefault_FixEncode(cstring& buf, fasttest::SampleSetDefault& parent, char soh) {
7739 buf << "1=" << parent.Value << soh;
7740}
7741
7742// --- fasttest.SclConst.base.CopyOut
7743// Copy fields out of row
7744void fasttest::parent_CopyOut(fasttest::SclConst &row, fasttest::TemplateHeader &out) {
7745 // length: field value is computed
7746 // id: field value is computed
7747 (void)row;//only to avoid -Wunused-parameter
7748 (void)out;//only to avoid -Wunused-parameter
7749}
7750
7751// --- fasttest.SclConst..ReadFieldMaybe
7752bool fasttest::SclConst_ReadFieldMaybe(fasttest::SclConst& parent, algo::strptr field, algo::strptr strval) {
7753 bool retval = true;
7754 fasttest::FieldId field_id;
7755 (void)value_SetStrptrMaybe(field_id,field);
7756 switch(field_id) {
7757 case fasttest_FieldId_base: {
7758 retval = false;
7759 break;
7760 }
7761 case fasttest_FieldId_length: {
7762 retval = false;
7763 break;
7764 }
7765 case fasttest_FieldId_id: {
7766 retval = false;
7767 break;
7768 }
7769 case fasttest_FieldId_Value: {
7770 retval = true;
7771 break;
7772 }
7773 default: break;
7774 }
7775 if (!retval) {
7776 algo_lib::AppendErrtext("attr",field);
7777 }
7778 (void)parent;//only to avoid -Wunused-parameter
7779 (void)strval;//only to avoid -Wunused-parameter
7780 return retval;
7781}
7782
7783// --- fasttest.SclConst..ReadStrptrMaybe
7784// Read fields of fasttest::SclConst from an ascii string.
7785// The format of the string is an ssim Tuple
7786bool fasttest::SclConst_ReadStrptrMaybe(fasttest::SclConst &parent, algo::strptr in_str) {
7787 bool retval = true;
7788 retval = algo::StripTypeTag(in_str, "fasttest.SclConst");
7789 ind_beg(algo::Attr_curs, attr, in_str) {
7790 retval = retval && SclConst_ReadFieldMaybe(parent, attr.name, attr.value);
7791 }ind_end;
7792 return retval;
7793}
7794
7795// --- fasttest.SclConst..Print
7796// print string representation of ROW to string STR
7797// cfmt:fasttest.SclConst.String printfmt:Tuple
7798void fasttest::SclConst_Print(fasttest::SclConst& row, algo::cstring& str) {
7799 algo::tempstr temp;
7800 str << "fasttest.SclConst";
7801
7802 algo::Decimal_Print(Value_Get(row), temp);
7803 PrintAttrSpaceReset(str,"Value", temp);
7804}
7805
7806// --- fasttest.SclConst..FastEncode
7807void fasttest::SclConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclConst& parent) {
7808 int index = ary_N(buf);
7809 u64 pmap(0);
7810 if (!tid_AssignedQ(state) || parent.id != state.tid) {
7811 lib_fast::EncodeUnsigned(buf,parent.id,false);
7812 lib_fast::SetPmapBit(pmap,0);
7813 }
7814 tid_SetAssigned(state);
7815 state.tid = parent.id;
7816 // Value scaled constant mandatory
7817 lib_fast::InsertPmap(buf,index,pmap);
7818}
7819
7820// --- fasttest.SclConst..FastDecode
7821bool fasttest::SclConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclConst& parent) {
7822 bool ok = true;
7823 // Value scaled constant mandatory
7824 if (ok) {
7825 }
7826 (void)from;//only to avoid -Wunused-parameter
7827 (void)pmap;//only to avoid -Wunused-parameter
7828 (void)state;//only to avoid -Wunused-parameter
7829 (void)parent;//only to avoid -Wunused-parameter
7830 return ok;
7831}
7832
7833// --- fasttest.SclConst..FixEncode
7834void fasttest::SclConst_FixEncode(cstring& buf, fasttest::SclConst& parent, char soh) {
7835 buf << "1=" << Value_Get(parent) << soh;
7836}
7837
7838// --- fasttest.SclConstOpt.base.CopyOut
7839// Copy fields out of row
7840void fasttest::parent_CopyOut(fasttest::SclConstOpt &row, fasttest::TemplateHeader &out) {
7841 // length: field value is computed
7842 // id: field value is computed
7843 (void)row;//only to avoid -Wunused-parameter
7844 (void)out;//only to avoid -Wunused-parameter
7845}
7846
7847// --- fasttest.SclConstOpt.pmask_bitcurs.Next
7848// proceed to next item
7849void fasttest::SclConstOpt_pmask_bitcurs_Next(SclConstOpt_pmask_bitcurs &curs) {
7850 ++curs.bit;
7851 int index = curs.bit / 32;
7852 int offset = curs.bit % 32;
7853 for (; index < curs.n_elems; ++index, offset = 0) {
7854 u64 rest = curs.elems[index] >> offset;
7855 if (rest) {
7856 offset += algo::u64_BitScanForward(rest);
7857 break;
7858 }
7859 }
7860 curs.bit = index * 32 + offset;
7861}
7862
7863// --- fasttest.SclConstOpt..ReadFieldMaybe
7864bool fasttest::SclConstOpt_ReadFieldMaybe(fasttest::SclConstOpt& parent, algo::strptr field, algo::strptr strval) {
7865 bool retval = true;
7866 fasttest::FieldId field_id;
7867 (void)value_SetStrptrMaybe(field_id,field);
7868 switch(field_id) {
7869 case fasttest_FieldId_base: {
7870 retval = false;
7871 break;
7872 }
7873 case fasttest_FieldId_length: {
7874 retval = false;
7875 break;
7876 }
7877 case fasttest_FieldId_id: {
7878 retval = false;
7879 break;
7880 }
7881 case fasttest_FieldId_pmask: {
7882 retval = false;
7883 break;
7884 }
7885 case fasttest_FieldId_Value: {
7886 retval = true;
7887 if (retval) {
7888 pmask_qSetBit(parent, 0);
7889 }
7890 break;
7891 }
7892 default: break;
7893 }
7894 if (!retval) {
7895 algo_lib::AppendErrtext("attr",field);
7896 }
7897 (void)strval;//only to avoid -Wunused-parameter
7898 return retval;
7899}
7900
7901// --- fasttest.SclConstOpt..ReadStrptrMaybe
7902// Read fields of fasttest::SclConstOpt from an ascii string.
7903// The format of the string is an ssim Tuple
7904bool fasttest::SclConstOpt_ReadStrptrMaybe(fasttest::SclConstOpt &parent, algo::strptr in_str) {
7905 bool retval = true;
7906 retval = algo::StripTypeTag(in_str, "fasttest.SclConstOpt");
7907 ind_beg(algo::Attr_curs, attr, in_str) {
7908 retval = retval && SclConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
7909 }ind_end;
7910 return retval;
7911}
7912
7913// --- fasttest.SclConstOpt..Print
7914// print string representation of ROW to string STR
7915// cfmt:fasttest.SclConstOpt.String printfmt:Tuple
7916void fasttest::SclConstOpt_Print(fasttest::SclConstOpt& row, algo::cstring& str) {
7917 algo::tempstr temp;
7918 str << "fasttest.SclConstOpt";
7919
7920 if (Value_PresentQ(row)) {
7921 algo::Decimal_Print(Value_Get(row), temp);
7922 PrintAttrSpaceReset(str,"Value", temp);
7923 }
7924}
7925
7926// --- fasttest.SclConstOpt..FastEncode
7927void fasttest::SclConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclConstOpt& parent) {
7928 int index = ary_N(buf);
7929 u64 pmap(0);
7930 if (!tid_AssignedQ(state) || parent.id != state.tid) {
7931 lib_fast::EncodeUnsigned(buf,parent.id,false);
7932 lib_fast::SetPmapBit(pmap,0);
7933 }
7934 tid_SetAssigned(state);
7935 state.tid = parent.id;
7936 // Value scaled constant optional
7937 if (Value_PresentQ(parent)) {
7938 lib_fast::SetPmapBit(pmap,1);
7939 }
7940 lib_fast::InsertPmap(buf,index,pmap);
7941}
7942
7943// --- fasttest.SclConstOpt..FastDecode
7944bool fasttest::SclConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclConstOpt& parent) {
7945 bool ok = true;
7946 // Value scaled constant optional
7947 if (ok) {
7948 bool prs = lib_fast::GetPmapBit(pmap,1);
7949 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
7950 }
7951 (void)from;//only to avoid -Wunused-parameter
7952 (void)state;//only to avoid -Wunused-parameter
7953 return ok;
7954}
7955
7956// --- fasttest.SclConstOpt..FixEncode
7957void fasttest::SclConstOpt_FixEncode(cstring& buf, fasttest::SclConstOpt& parent, char soh) {
7958 if (Value_PresentQ(parent)) {
7959 buf << "1=" << Value_Get(parent) << soh;
7960 }
7961}
7962
7963// --- fasttest.SclCopy.base.CopyOut
7964// Copy fields out of row
7965void fasttest::parent_CopyOut(fasttest::SclCopy &row, fasttest::TemplateHeader &out) {
7966 // length: field value is computed
7967 // id: field value is computed
7968 (void)row;//only to avoid -Wunused-parameter
7969 (void)out;//only to avoid -Wunused-parameter
7970}
7971
7972// --- fasttest.SclCopy..ReadFieldMaybe
7973bool fasttest::SclCopy_ReadFieldMaybe(fasttest::SclCopy& parent, algo::strptr field, algo::strptr strval) {
7974 bool retval = true;
7975 fasttest::FieldId field_id;
7976 (void)value_SetStrptrMaybe(field_id,field);
7977 switch(field_id) {
7978 case fasttest_FieldId_base: {
7979 retval = false;
7980 break;
7981 }
7982 case fasttest_FieldId_length: {
7983 retval = false;
7984 break;
7985 }
7986 case fasttest_FieldId_id: {
7987 retval = false;
7988 break;
7989 }
7990 case fasttest_FieldId_Value61: {
7991 retval = algo::Decimal_ReadStrptrMaybe(parent.Value61, strval);
7992 break;
7993 }
7994 default: break;
7995 }
7996 if (!retval) {
7997 algo_lib::AppendErrtext("attr",field);
7998 }
7999 return retval;
8000}
8001
8002// --- fasttest.SclCopy..ReadStrptrMaybe
8003// Read fields of fasttest::SclCopy from an ascii string.
8004// The format of the string is an ssim Tuple
8005bool fasttest::SclCopy_ReadStrptrMaybe(fasttest::SclCopy &parent, algo::strptr in_str) {
8006 bool retval = true;
8007 retval = algo::StripTypeTag(in_str, "fasttest.SclCopy");
8008 ind_beg(algo::Attr_curs, attr, in_str) {
8009 retval = retval && SclCopy_ReadFieldMaybe(parent, attr.name, attr.value);
8010 }ind_end;
8011 return retval;
8012}
8013
8014// --- fasttest.SclCopy..Print
8015// print string representation of ROW to string STR
8016// cfmt:fasttest.SclCopy.String printfmt:Tuple
8017void fasttest::SclCopy_Print(fasttest::SclCopy& row, algo::cstring& str) {
8018 algo::tempstr temp;
8019 str << "fasttest.SclCopy";
8020
8021 algo::Decimal_Print(row.Value61, temp);
8022 PrintAttrSpaceReset(str,"Value61", temp);
8023}
8024
8025// --- fasttest.SclCopy..FastEncode
8026void fasttest::SclCopy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclCopy& parent) {
8027 int index = ary_N(buf);
8028 u64 pmap(0);
8029 if (!tid_AssignedQ(state) || parent.id != state.tid) {
8030 lib_fast::EncodeUnsigned(buf,parent.id,false);
8031 lib_fast::SetPmapBit(pmap,0);
8032 }
8033 tid_SetAssigned(state);
8034 state.tid = parent.id;
8035 // Value61 scaled copy mandatory
8036 if (Value61_AssignedQ(state) ? parent.Value61 != state.Value61 : parent.Value61 != algo::Decimal(-2,-61)) {
8037 lib_fast::EncodeScaled(buf,parent.Value61,false);
8038 lib_fast::SetPmapBit(pmap,1);
8039 }
8040 state.Value61 = parent.Value61;
8041 Value61_SetAssigned(state);
8042 lib_fast::InsertPmap(buf,index,pmap);
8043}
8044
8045// --- fasttest.SclCopy..FastDecode
8046bool fasttest::SclCopy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclCopy& parent) {
8047 bool ok = true;
8048 // Value61 scaled copy mandatory
8049 if (ok) {
8050 bool prs = lib_fast::GetPmapBit(pmap,1);
8051 if (prs) {
8052 ok = lib_fast::DecodeScaled(from,parent.Value61,false);
8053 if (!ok) {
8054 state.error << "fasttest.SclCopy.Value61: bad Scaled" << eol;
8055 }
8056 } else if (Value61_AssignedQ(state)) {
8057 parent.Value61 = state.Value61;
8058 } else {
8059 parent.Value61 = algo::Decimal(-2,-61);
8060 }
8061 Value61_SetAssigned(state);
8062 state.Value61 = parent.Value61;
8063 }
8064 return ok;
8065}
8066
8067// --- fasttest.SclCopy..FixEncode
8068void fasttest::SclCopy_FixEncode(cstring& buf, fasttest::SclCopy& parent, char soh) {
8069 buf << "1=" << parent.Value61 << soh;
8070}
8071
8072// --- fasttest.SclCopyNull.base.CopyOut
8073// Copy fields out of row
8074void fasttest::parent_CopyOut(fasttest::SclCopyNull &row, fasttest::TemplateHeader &out) {
8075 // length: field value is computed
8076 // id: field value is computed
8077 (void)row;//only to avoid -Wunused-parameter
8078 (void)out;//only to avoid -Wunused-parameter
8079}
8080
8081// --- fasttest.SclCopyNull.Value63.ReadStrptrMaybe
8082inline static bool fasttest::Value63_ReadStrptrMaybe(fasttest::SclCopyNull &parent, algo::strptr in_str) {
8083 bool retval = true;
8084 algo::Decimal Value63_tmp;
8085 retval = algo::Decimal_ReadStrptrMaybe(Value63_tmp, in_str);
8086 if (retval) {
8087 Value63_Set(parent, Value63_tmp);
8088 }
8089 return retval;
8090}
8091
8092// --- fasttest.SclCopyNull.pmask_bitcurs.Next
8093// proceed to next item
8094void fasttest::SclCopyNull_pmask_bitcurs_Next(SclCopyNull_pmask_bitcurs &curs) {
8095 ++curs.bit;
8096 int index = curs.bit / 32;
8097 int offset = curs.bit % 32;
8098 for (; index < curs.n_elems; ++index, offset = 0) {
8099 u64 rest = curs.elems[index] >> offset;
8100 if (rest) {
8101 offset += algo::u64_BitScanForward(rest);
8102 break;
8103 }
8104 }
8105 curs.bit = index * 32 + offset;
8106}
8107
8108// --- fasttest.SclCopyNull..ReadFieldMaybe
8109bool fasttest::SclCopyNull_ReadFieldMaybe(fasttest::SclCopyNull& parent, algo::strptr field, algo::strptr strval) {
8110 bool retval = true;
8111 fasttest::FieldId field_id;
8112 (void)value_SetStrptrMaybe(field_id,field);
8113 switch(field_id) {
8114 case fasttest_FieldId_base: {
8115 retval = false;
8116 break;
8117 }
8118 case fasttest_FieldId_length: {
8119 retval = false;
8120 break;
8121 }
8122 case fasttest_FieldId_id: {
8123 retval = false;
8124 break;
8125 }
8126 case fasttest_FieldId_pmask: {
8127 retval = false;
8128 break;
8129 }
8130 case fasttest_FieldId_Value63: {
8131 retval = Value63_ReadStrptrMaybe(parent, strval);
8132 if (retval) {
8133 pmask_qSetBit(parent, 0);
8134 }
8135 break;
8136 }
8137 default: break;
8138 }
8139 if (!retval) {
8140 algo_lib::AppendErrtext("attr",field);
8141 }
8142 return retval;
8143}
8144
8145// --- fasttest.SclCopyNull..ReadStrptrMaybe
8146// Read fields of fasttest::SclCopyNull from an ascii string.
8147// The format of the string is an ssim Tuple
8148bool fasttest::SclCopyNull_ReadStrptrMaybe(fasttest::SclCopyNull &parent, algo::strptr in_str) {
8149 bool retval = true;
8150 retval = algo::StripTypeTag(in_str, "fasttest.SclCopyNull");
8151 ind_beg(algo::Attr_curs, attr, in_str) {
8152 retval = retval && SclCopyNull_ReadFieldMaybe(parent, attr.name, attr.value);
8153 }ind_end;
8154 return retval;
8155}
8156
8157// --- fasttest.SclCopyNull..Print
8158// print string representation of ROW to string STR
8159// cfmt:fasttest.SclCopyNull.String printfmt:Tuple
8160void fasttest::SclCopyNull_Print(fasttest::SclCopyNull& row, algo::cstring& str) {
8161 algo::tempstr temp;
8162 str << "fasttest.SclCopyNull";
8163
8164 if (Value63_PresentQ(row)) {
8165 algo::Decimal_Print(row.Value63, temp);
8166 PrintAttrSpaceReset(str,"Value63", temp);
8167 }
8168}
8169
8170// --- fasttest.SclCopyNull..FastEncode
8171void fasttest::SclCopyNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclCopyNull& parent) {
8172 int index = ary_N(buf);
8173 u64 pmap(0);
8174 if (!tid_AssignedQ(state) || parent.id != state.tid) {
8175 lib_fast::EncodeUnsigned(buf,parent.id,false);
8176 lib_fast::SetPmapBit(pmap,0);
8177 }
8178 tid_SetAssigned(state);
8179 state.tid = parent.id;
8180 // Value63 scaled copy optional
8181 if (Value63_PresentQ(parent)) {
8182 if (Value63_AssignedQ(state) ? !Value63_PresentQ(state) || parent.Value63 != state.Value63 : parent.Value63 != algo::Decimal(0,0)) {
8183 lib_fast::EncodeScaled(buf,parent.Value63,true);
8184 lib_fast::SetPmapBit(pmap,1);
8185 }
8186 } else {
8187 if (Value63_AssignedQ(state) && Value63_PresentQ(state)) {
8188 lib_fast::EncodeNull(buf);
8189 lib_fast::SetPmapBit(pmap,1);
8190 }
8191 }
8192 state.Value63 = parent.Value63;
8193 present_qSetBitVal(state,Value63_Present_GetBit(state),Value63_PresentQ(parent));
8194 Value63_SetAssigned(state);
8195 lib_fast::InsertPmap(buf,index,pmap);
8196}
8197
8198// --- fasttest.SclCopyNull..FastDecode
8199bool fasttest::SclCopyNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclCopyNull& parent) {
8200 bool ok = true;
8201 // Value63 scaled copy optional
8202 if (ok) {
8203 bool prs = lib_fast::GetPmapBit(pmap,1);
8204 if (prs) {
8205 prs = !lib_fast::DecodeNull(from);
8206 if (prs) {
8207 ok = lib_fast::DecodeScaled(from,parent.Value63,true);
8208 if (!ok) {
8209 state.error << "fasttest.SclCopyNull.Value63: bad Scaled" << eol;
8210 }
8211 }
8212 } else if (Value63_AssignedQ(state)) {
8213 parent.Value63 = state.Value63;
8214 prs = Value63_PresentQ(state);
8215 } else {
8216 parent.Value63 = algo::Decimal(0,0);
8217 prs = true;
8218 }
8219 pmask_qSetBitVal(parent,Value63_Present_GetBit(parent),prs);
8220 Value63_SetAssigned(state);
8221 present_qSetBitVal(state,Value63_Present_GetBit(state),prs);
8222 state.Value63 = parent.Value63;
8223 }
8224 return ok;
8225}
8226
8227// --- fasttest.SclCopyNull..FixEncode
8228void fasttest::SclCopyNull_FixEncode(cstring& buf, fasttest::SclCopyNull& parent, char soh) {
8229 if (Value63_PresentQ(parent)) {
8230 buf << "1=" << parent.Value63 << soh;
8231 }
8232}
8233
8234// --- fasttest.SclCopyOpt.base.CopyOut
8235// Copy fields out of row
8236void fasttest::parent_CopyOut(fasttest::SclCopyOpt &row, fasttest::TemplateHeader &out) {
8237 // length: field value is computed
8238 // id: field value is computed
8239 (void)row;//only to avoid -Wunused-parameter
8240 (void)out;//only to avoid -Wunused-parameter
8241}
8242
8243// --- fasttest.SclCopyOpt.Value62.ReadStrptrMaybe
8244inline static bool fasttest::Value62_ReadStrptrMaybe(fasttest::SclCopyOpt &parent, algo::strptr in_str) {
8245 bool retval = true;
8246 algo::Decimal Value62_tmp;
8247 retval = algo::Decimal_ReadStrptrMaybe(Value62_tmp, in_str);
8248 if (retval) {
8249 Value62_Set(parent, Value62_tmp);
8250 }
8251 return retval;
8252}
8253
8254// --- fasttest.SclCopyOpt.pmask_bitcurs.Next
8255// proceed to next item
8256void fasttest::SclCopyOpt_pmask_bitcurs_Next(SclCopyOpt_pmask_bitcurs &curs) {
8257 ++curs.bit;
8258 int index = curs.bit / 32;
8259 int offset = curs.bit % 32;
8260 for (; index < curs.n_elems; ++index, offset = 0) {
8261 u64 rest = curs.elems[index] >> offset;
8262 if (rest) {
8263 offset += algo::u64_BitScanForward(rest);
8264 break;
8265 }
8266 }
8267 curs.bit = index * 32 + offset;
8268}
8269
8270// --- fasttest.SclCopyOpt..ReadFieldMaybe
8271bool fasttest::SclCopyOpt_ReadFieldMaybe(fasttest::SclCopyOpt& parent, algo::strptr field, algo::strptr strval) {
8272 bool retval = true;
8273 fasttest::FieldId field_id;
8274 (void)value_SetStrptrMaybe(field_id,field);
8275 switch(field_id) {
8276 case fasttest_FieldId_base: {
8277 retval = false;
8278 break;
8279 }
8280 case fasttest_FieldId_length: {
8281 retval = false;
8282 break;
8283 }
8284 case fasttest_FieldId_id: {
8285 retval = false;
8286 break;
8287 }
8288 case fasttest_FieldId_pmask: {
8289 retval = false;
8290 break;
8291 }
8292 case fasttest_FieldId_Value62: {
8293 retval = Value62_ReadStrptrMaybe(parent, strval);
8294 if (retval) {
8295 pmask_qSetBit(parent, 0);
8296 }
8297 break;
8298 }
8299 default: break;
8300 }
8301 if (!retval) {
8302 algo_lib::AppendErrtext("attr",field);
8303 }
8304 return retval;
8305}
8306
8307// --- fasttest.SclCopyOpt..ReadStrptrMaybe
8308// Read fields of fasttest::SclCopyOpt from an ascii string.
8309// The format of the string is an ssim Tuple
8310bool fasttest::SclCopyOpt_ReadStrptrMaybe(fasttest::SclCopyOpt &parent, algo::strptr in_str) {
8311 bool retval = true;
8312 retval = algo::StripTypeTag(in_str, "fasttest.SclCopyOpt");
8313 ind_beg(algo::Attr_curs, attr, in_str) {
8314 retval = retval && SclCopyOpt_ReadFieldMaybe(parent, attr.name, attr.value);
8315 }ind_end;
8316 return retval;
8317}
8318
8319// --- fasttest.SclCopyOpt..Print
8320// print string representation of ROW to string STR
8321// cfmt:fasttest.SclCopyOpt.String printfmt:Tuple
8322void fasttest::SclCopyOpt_Print(fasttest::SclCopyOpt& row, algo::cstring& str) {
8323 algo::tempstr temp;
8324 str << "fasttest.SclCopyOpt";
8325
8326 if (Value62_PresentQ(row)) {
8327 algo::Decimal_Print(row.Value62, temp);
8328 PrintAttrSpaceReset(str,"Value62", temp);
8329 }
8330}
8331
8332// --- fasttest.SclCopyOpt..FastEncode
8333void fasttest::SclCopyOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclCopyOpt& parent) {
8334 int index = ary_N(buf);
8335 u64 pmap(0);
8336 if (!tid_AssignedQ(state) || parent.id != state.tid) {
8337 lib_fast::EncodeUnsigned(buf,parent.id,false);
8338 lib_fast::SetPmapBit(pmap,0);
8339 }
8340 tid_SetAssigned(state);
8341 state.tid = parent.id;
8342 // Value62 scaled copy optional
8343 if (Value62_PresentQ(parent)) {
8344 if (Value62_AssignedQ(state) ? !Value62_PresentQ(state) || parent.Value62 != state.Value62 : parent.Value62 != algo::Decimal(1,-62)) {
8345 lib_fast::EncodeScaled(buf,parent.Value62,true);
8346 lib_fast::SetPmapBit(pmap,1);
8347 }
8348 } else {
8349 if (Value62_AssignedQ(state) && Value62_PresentQ(state)) {
8350 lib_fast::EncodeNull(buf);
8351 lib_fast::SetPmapBit(pmap,1);
8352 }
8353 }
8354 state.Value62 = parent.Value62;
8355 present_qSetBitVal(state,Value62_Present_GetBit(state),Value62_PresentQ(parent));
8356 Value62_SetAssigned(state);
8357 lib_fast::InsertPmap(buf,index,pmap);
8358}
8359
8360// --- fasttest.SclCopyOpt..FastDecode
8361bool fasttest::SclCopyOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclCopyOpt& parent) {
8362 bool ok = true;
8363 // Value62 scaled copy optional
8364 if (ok) {
8365 bool prs = lib_fast::GetPmapBit(pmap,1);
8366 if (prs) {
8367 prs = !lib_fast::DecodeNull(from);
8368 if (prs) {
8369 ok = lib_fast::DecodeScaled(from,parent.Value62,true);
8370 if (!ok) {
8371 state.error << "fasttest.SclCopyOpt.Value62: bad Scaled" << eol;
8372 }
8373 }
8374 } else if (Value62_AssignedQ(state)) {
8375 parent.Value62 = state.Value62;
8376 prs = Value62_PresentQ(state);
8377 } else {
8378 parent.Value62 = algo::Decimal(1,-62);
8379 prs = true;
8380 }
8381 pmask_qSetBitVal(parent,Value62_Present_GetBit(parent),prs);
8382 Value62_SetAssigned(state);
8383 present_qSetBitVal(state,Value62_Present_GetBit(state),prs);
8384 state.Value62 = parent.Value62;
8385 }
8386 return ok;
8387}
8388
8389// --- fasttest.SclCopyOpt..FixEncode
8390void fasttest::SclCopyOpt_FixEncode(cstring& buf, fasttest::SclCopyOpt& parent, char soh) {
8391 if (Value62_PresentQ(parent)) {
8392 buf << "1=" << parent.Value62 << soh;
8393 }
8394}
8395
8396// --- fasttest.SclDelta.base.CopyOut
8397// Copy fields out of row
8398void fasttest::parent_CopyOut(fasttest::SclDelta &row, fasttest::TemplateHeader &out) {
8399 // length: field value is computed
8400 // id: field value is computed
8401 (void)row;//only to avoid -Wunused-parameter
8402 (void)out;//only to avoid -Wunused-parameter
8403}
8404
8405// --- fasttest.SclDelta..ReadFieldMaybe
8406bool fasttest::SclDelta_ReadFieldMaybe(fasttest::SclDelta& parent, algo::strptr field, algo::strptr strval) {
8407 bool retval = true;
8408 fasttest::FieldId field_id;
8409 (void)value_SetStrptrMaybe(field_id,field);
8410 switch(field_id) {
8411 case fasttest_FieldId_base: {
8412 retval = false;
8413 break;
8414 }
8415 case fasttest_FieldId_length: {
8416 retval = false;
8417 break;
8418 }
8419 case fasttest_FieldId_id: {
8420 retval = false;
8421 break;
8422 }
8423 case fasttest_FieldId_Value81: {
8424 retval = algo::Decimal_ReadStrptrMaybe(parent.Value81, strval);
8425 break;
8426 }
8427 default: break;
8428 }
8429 if (!retval) {
8430 algo_lib::AppendErrtext("attr",field);
8431 }
8432 return retval;
8433}
8434
8435// --- fasttest.SclDelta..ReadStrptrMaybe
8436// Read fields of fasttest::SclDelta from an ascii string.
8437// The format of the string is an ssim Tuple
8438bool fasttest::SclDelta_ReadStrptrMaybe(fasttest::SclDelta &parent, algo::strptr in_str) {
8439 bool retval = true;
8440 retval = algo::StripTypeTag(in_str, "fasttest.SclDelta");
8441 ind_beg(algo::Attr_curs, attr, in_str) {
8442 retval = retval && SclDelta_ReadFieldMaybe(parent, attr.name, attr.value);
8443 }ind_end;
8444 return retval;
8445}
8446
8447// --- fasttest.SclDelta..Print
8448// print string representation of ROW to string STR
8449// cfmt:fasttest.SclDelta.String printfmt:Tuple
8450void fasttest::SclDelta_Print(fasttest::SclDelta& row, algo::cstring& str) {
8451 algo::tempstr temp;
8452 str << "fasttest.SclDelta";
8453
8454 algo::Decimal_Print(row.Value81, temp);
8455 PrintAttrSpaceReset(str,"Value81", temp);
8456}
8457
8458// --- fasttest.SclDelta..FastEncode
8459void fasttest::SclDelta_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDelta& parent) {
8460 int index = ary_N(buf);
8461 u64 pmap(0);
8462 if (!tid_AssignedQ(state) || parent.id != state.tid) {
8463 lib_fast::EncodeUnsigned(buf,parent.id,false);
8464 lib_fast::SetPmapBit(pmap,0);
8465 }
8466 tid_SetAssigned(state);
8467 state.tid = parent.id;
8468 // Value81 scaled delta mandatory
8469 if (!Value81_AssignedQ(state)) {
8470 Value81_SetAssigned(state);
8471 state.Value81 = algo::Decimal(-2,-81);
8472 }
8473 lib_fast::EncodeDeltaScaled(buf,state.Value81,parent.Value81,false);
8474 state.Value81 = parent.Value81;
8475 lib_fast::InsertPmap(buf,index,pmap);
8476}
8477
8478// --- fasttest.SclDelta..FastDecode
8479bool fasttest::SclDelta_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDelta& parent) {
8480 bool ok = true;
8481 // Value81 scaled delta mandatory
8482 if (ok) {
8483 if (!Value81_AssignedQ(state)) {
8484 Value81_SetAssigned(state);
8485 state.Value81 = algo::Decimal(-2,-81);
8486 }
8487 ok = lib_fast::DecodeDeltaScaled(from,state.Value81,parent.Value81,false);
8488 if (!ok) {
8489 state.error << "fasttest.SclDelta.Value81: bad Scaled delta" << eol;
8490 }
8491 state.Value81 = parent.Value81;
8492 }
8493 (void)pmap;//only to avoid -Wunused-parameter
8494 return ok;
8495}
8496
8497// --- fasttest.SclDelta..FixEncode
8498void fasttest::SclDelta_FixEncode(cstring& buf, fasttest::SclDelta& parent, char soh) {
8499 buf << "1=" << parent.Value81 << soh;
8500}
8501
8502// --- fasttest.SclDeltaImpl.base.CopyOut
8503// Copy fields out of row
8504void fasttest::parent_CopyOut(fasttest::SclDeltaImpl &row, fasttest::TemplateHeader &out) {
8505 // length: field value is computed
8506 // id: field value is computed
8507 (void)row;//only to avoid -Wunused-parameter
8508 (void)out;//only to avoid -Wunused-parameter
8509}
8510
8511// --- fasttest.SclDeltaImpl..ReadFieldMaybe
8512bool fasttest::SclDeltaImpl_ReadFieldMaybe(fasttest::SclDeltaImpl& parent, algo::strptr field, algo::strptr strval) {
8513 bool retval = true;
8514 fasttest::FieldId field_id;
8515 (void)value_SetStrptrMaybe(field_id,field);
8516 switch(field_id) {
8517 case fasttest_FieldId_base: {
8518 retval = false;
8519 break;
8520 }
8521 case fasttest_FieldId_length: {
8522 retval = false;
8523 break;
8524 }
8525 case fasttest_FieldId_id: {
8526 retval = false;
8527 break;
8528 }
8529 case fasttest_FieldId_Value82: {
8530 retval = algo::Decimal_ReadStrptrMaybe(parent.Value82, strval);
8531 break;
8532 }
8533 default: break;
8534 }
8535 if (!retval) {
8536 algo_lib::AppendErrtext("attr",field);
8537 }
8538 return retval;
8539}
8540
8541// --- fasttest.SclDeltaImpl..ReadStrptrMaybe
8542// Read fields of fasttest::SclDeltaImpl from an ascii string.
8543// The format of the string is an ssim Tuple
8544bool fasttest::SclDeltaImpl_ReadStrptrMaybe(fasttest::SclDeltaImpl &parent, algo::strptr in_str) {
8545 bool retval = true;
8546 retval = algo::StripTypeTag(in_str, "fasttest.SclDeltaImpl");
8547 ind_beg(algo::Attr_curs, attr, in_str) {
8548 retval = retval && SclDeltaImpl_ReadFieldMaybe(parent, attr.name, attr.value);
8549 }ind_end;
8550 return retval;
8551}
8552
8553// --- fasttest.SclDeltaImpl..Print
8554// print string representation of ROW to string STR
8555// cfmt:fasttest.SclDeltaImpl.String printfmt:Tuple
8556void fasttest::SclDeltaImpl_Print(fasttest::SclDeltaImpl& row, algo::cstring& str) {
8557 algo::tempstr temp;
8558 str << "fasttest.SclDeltaImpl";
8559
8560 algo::Decimal_Print(row.Value82, temp);
8561 PrintAttrSpaceReset(str,"Value82", temp);
8562}
8563
8564// --- fasttest.SclDeltaImpl..FastEncode
8565void fasttest::SclDeltaImpl_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDeltaImpl& parent) {
8566 int index = ary_N(buf);
8567 u64 pmap(0);
8568 if (!tid_AssignedQ(state) || parent.id != state.tid) {
8569 lib_fast::EncodeUnsigned(buf,parent.id,false);
8570 lib_fast::SetPmapBit(pmap,0);
8571 }
8572 tid_SetAssigned(state);
8573 state.tid = parent.id;
8574 // Value82 scaled delta mandatory
8575 if (!Value82_AssignedQ(state)) {
8576 Value82_SetAssigned(state);
8577 state.Value82 = algo::Decimal(0,0);
8578 }
8579 lib_fast::EncodeDeltaScaled(buf,state.Value82,parent.Value82,false);
8580 state.Value82 = parent.Value82;
8581 lib_fast::InsertPmap(buf,index,pmap);
8582}
8583
8584// --- fasttest.SclDeltaImpl..FastDecode
8585bool fasttest::SclDeltaImpl_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDeltaImpl& parent) {
8586 bool ok = true;
8587 // Value82 scaled delta mandatory
8588 if (ok) {
8589 if (!Value82_AssignedQ(state)) {
8590 Value82_SetAssigned(state);
8591 state.Value82 = algo::Decimal(0,0);
8592 }
8593 ok = lib_fast::DecodeDeltaScaled(from,state.Value82,parent.Value82,false);
8594 if (!ok) {
8595 state.error << "fasttest.SclDeltaImpl.Value82: bad Scaled delta" << eol;
8596 }
8597 state.Value82 = parent.Value82;
8598 }
8599 (void)pmap;//only to avoid -Wunused-parameter
8600 return ok;
8601}
8602
8603// --- fasttest.SclDeltaImpl..FixEncode
8604void fasttest::SclDeltaImpl_FixEncode(cstring& buf, fasttest::SclDeltaImpl& parent, char soh) {
8605 buf << "1=" << parent.Value82 << soh;
8606}
8607
8608// --- fasttest.SclDeltaNull.base.CopyOut
8609// Copy fields out of row
8610void fasttest::parent_CopyOut(fasttest::SclDeltaNull &row, fasttest::TemplateHeader &out) {
8611 // length: field value is computed
8612 // id: field value is computed
8613 (void)row;//only to avoid -Wunused-parameter
8614 (void)out;//only to avoid -Wunused-parameter
8615}
8616
8617// --- fasttest.SclDeltaNull.Value84.ReadStrptrMaybe
8618inline static bool fasttest::Value84_ReadStrptrMaybe(fasttest::SclDeltaNull &parent, algo::strptr in_str) {
8619 bool retval = true;
8620 algo::Decimal Value84_tmp;
8621 retval = algo::Decimal_ReadStrptrMaybe(Value84_tmp, in_str);
8622 if (retval) {
8623 Value84_Set(parent, Value84_tmp);
8624 }
8625 return retval;
8626}
8627
8628// --- fasttest.SclDeltaNull.pmask_bitcurs.Next
8629// proceed to next item
8630void fasttest::SclDeltaNull_pmask_bitcurs_Next(SclDeltaNull_pmask_bitcurs &curs) {
8631 ++curs.bit;
8632 int index = curs.bit / 32;
8633 int offset = curs.bit % 32;
8634 for (; index < curs.n_elems; ++index, offset = 0) {
8635 u64 rest = curs.elems[index] >> offset;
8636 if (rest) {
8637 offset += algo::u64_BitScanForward(rest);
8638 break;
8639 }
8640 }
8641 curs.bit = index * 32 + offset;
8642}
8643
8644// --- fasttest.SclDeltaNull..ReadFieldMaybe
8645bool fasttest::SclDeltaNull_ReadFieldMaybe(fasttest::SclDeltaNull& parent, algo::strptr field, algo::strptr strval) {
8646 bool retval = true;
8647 fasttest::FieldId field_id;
8648 (void)value_SetStrptrMaybe(field_id,field);
8649 switch(field_id) {
8650 case fasttest_FieldId_base: {
8651 retval = false;
8652 break;
8653 }
8654 case fasttest_FieldId_length: {
8655 retval = false;
8656 break;
8657 }
8658 case fasttest_FieldId_id: {
8659 retval = false;
8660 break;
8661 }
8662 case fasttest_FieldId_pmask: {
8663 retval = false;
8664 break;
8665 }
8666 case fasttest_FieldId_Value84: {
8667 retval = Value84_ReadStrptrMaybe(parent, strval);
8668 if (retval) {
8669 pmask_qSetBit(parent, 0);
8670 }
8671 break;
8672 }
8673 default: break;
8674 }
8675 if (!retval) {
8676 algo_lib::AppendErrtext("attr",field);
8677 }
8678 return retval;
8679}
8680
8681// --- fasttest.SclDeltaNull..ReadStrptrMaybe
8682// Read fields of fasttest::SclDeltaNull from an ascii string.
8683// The format of the string is an ssim Tuple
8684bool fasttest::SclDeltaNull_ReadStrptrMaybe(fasttest::SclDeltaNull &parent, algo::strptr in_str) {
8685 bool retval = true;
8686 retval = algo::StripTypeTag(in_str, "fasttest.SclDeltaNull");
8687 ind_beg(algo::Attr_curs, attr, in_str) {
8688 retval = retval && SclDeltaNull_ReadFieldMaybe(parent, attr.name, attr.value);
8689 }ind_end;
8690 return retval;
8691}
8692
8693// --- fasttest.SclDeltaNull..Print
8694// print string representation of ROW to string STR
8695// cfmt:fasttest.SclDeltaNull.String printfmt:Tuple
8696void fasttest::SclDeltaNull_Print(fasttest::SclDeltaNull& row, algo::cstring& str) {
8697 algo::tempstr temp;
8698 str << "fasttest.SclDeltaNull";
8699
8700 if (Value84_PresentQ(row)) {
8701 algo::Decimal_Print(row.Value84, temp);
8702 PrintAttrSpaceReset(str,"Value84", temp);
8703 }
8704}
8705
8706// --- fasttest.SclDeltaNull..FastEncode
8707void fasttest::SclDeltaNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDeltaNull& parent) {
8708 int index = ary_N(buf);
8709 u64 pmap(0);
8710 if (!tid_AssignedQ(state) || parent.id != state.tid) {
8711 lib_fast::EncodeUnsigned(buf,parent.id,false);
8712 lib_fast::SetPmapBit(pmap,0);
8713 }
8714 tid_SetAssigned(state);
8715 state.tid = parent.id;
8716 // Value84 scaled delta optional
8717 if (!Value84_AssignedQ(state)) {
8718 Value84_SetAssigned(state);
8719 present_qSetBitVal(state,Value84_Present_GetBit(state),Value84_PresentQ(parent));
8720 state.Value84 = algo::Decimal(0,0);
8721 }
8722 if (Value84_PresentQ(parent)) {
8723 if (!Value84_PresentQ(state)) {
8724 state.Value84 = algo::Decimal(0,0);
8725 }
8726 lib_fast::EncodeDeltaScaled(buf,state.Value84,parent.Value84,true);
8727 } else {
8728 lib_fast::EncodeNull(buf);
8729 }
8730 state.Value84 = parent.Value84;
8731 present_qSetBitVal(state,Value84_Present_GetBit(state),Value84_PresentQ(parent));
8732 lib_fast::InsertPmap(buf,index,pmap);
8733}
8734
8735// --- fasttest.SclDeltaNull..FastDecode
8736bool fasttest::SclDeltaNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDeltaNull& parent) {
8737 bool ok = true;
8738 // Value84 scaled delta optional
8739 if (ok) {
8740 if (!Value84_AssignedQ(state)) {
8741 Value84_SetAssigned(state);
8742 bool prs(true);
8743 present_qSetBitVal(state,Value84_Present_GetBit(state),prs);
8744 state.Value84 = algo::Decimal(0,0);
8745 }
8746 bool prs = !lib_fast::DecodeNull(from);
8747 if (prs) {
8748 if (!Value84_PresentQ(state)) {
8749 state.Value84 = algo::Decimal(0,0);
8750 }
8751 ok = lib_fast::DecodeDeltaScaled(from,state.Value84,parent.Value84,true);
8752 if (!ok) {
8753 state.error << "fasttest.SclDeltaNull.Value84: bad Scaled delta" << eol;
8754 }
8755 state.Value84 = parent.Value84;
8756 }
8757 pmask_qSetBitVal(parent,Value84_Present_GetBit(parent),prs);
8758 present_qSetBitVal(state,Value84_Present_GetBit(state),prs);
8759 }
8760 (void)pmap;//only to avoid -Wunused-parameter
8761 return ok;
8762}
8763
8764// --- fasttest.SclDeltaNull..FixEncode
8765void fasttest::SclDeltaNull_FixEncode(cstring& buf, fasttest::SclDeltaNull& parent, char soh) {
8766 if (Value84_PresentQ(parent)) {
8767 buf << "1=" << parent.Value84 << soh;
8768 }
8769}
8770
8771// --- fasttest.SclDeltaOpt.base.CopyOut
8772// Copy fields out of row
8773void fasttest::parent_CopyOut(fasttest::SclDeltaOpt &row, fasttest::TemplateHeader &out) {
8774 // length: field value is computed
8775 // id: field value is computed
8776 (void)row;//only to avoid -Wunused-parameter
8777 (void)out;//only to avoid -Wunused-parameter
8778}
8779
8780// --- fasttest.SclDeltaOpt.Value83.ReadStrptrMaybe
8781inline static bool fasttest::Value83_ReadStrptrMaybe(fasttest::SclDeltaOpt &parent, algo::strptr in_str) {
8782 bool retval = true;
8783 algo::Decimal Value83_tmp;
8784 retval = algo::Decimal_ReadStrptrMaybe(Value83_tmp, in_str);
8785 if (retval) {
8786 Value83_Set(parent, Value83_tmp);
8787 }
8788 return retval;
8789}
8790
8791// --- fasttest.SclDeltaOpt.pmask_bitcurs.Next
8792// proceed to next item
8793void fasttest::SclDeltaOpt_pmask_bitcurs_Next(SclDeltaOpt_pmask_bitcurs &curs) {
8794 ++curs.bit;
8795 int index = curs.bit / 32;
8796 int offset = curs.bit % 32;
8797 for (; index < curs.n_elems; ++index, offset = 0) {
8798 u64 rest = curs.elems[index] >> offset;
8799 if (rest) {
8800 offset += algo::u64_BitScanForward(rest);
8801 break;
8802 }
8803 }
8804 curs.bit = index * 32 + offset;
8805}
8806
8807// --- fasttest.SclDeltaOpt..ReadFieldMaybe
8808bool fasttest::SclDeltaOpt_ReadFieldMaybe(fasttest::SclDeltaOpt& parent, algo::strptr field, algo::strptr strval) {
8809 bool retval = true;
8810 fasttest::FieldId field_id;
8811 (void)value_SetStrptrMaybe(field_id,field);
8812 switch(field_id) {
8813 case fasttest_FieldId_base: {
8814 retval = false;
8815 break;
8816 }
8817 case fasttest_FieldId_length: {
8818 retval = false;
8819 break;
8820 }
8821 case fasttest_FieldId_id: {
8822 retval = false;
8823 break;
8824 }
8825 case fasttest_FieldId_pmask: {
8826 retval = false;
8827 break;
8828 }
8829 case fasttest_FieldId_Value83: {
8830 retval = Value83_ReadStrptrMaybe(parent, strval);
8831 if (retval) {
8832 pmask_qSetBit(parent, 0);
8833 }
8834 break;
8835 }
8836 default: break;
8837 }
8838 if (!retval) {
8839 algo_lib::AppendErrtext("attr",field);
8840 }
8841 return retval;
8842}
8843
8844// --- fasttest.SclDeltaOpt..ReadStrptrMaybe
8845// Read fields of fasttest::SclDeltaOpt from an ascii string.
8846// The format of the string is an ssim Tuple
8847bool fasttest::SclDeltaOpt_ReadStrptrMaybe(fasttest::SclDeltaOpt &parent, algo::strptr in_str) {
8848 bool retval = true;
8849 retval = algo::StripTypeTag(in_str, "fasttest.SclDeltaOpt");
8850 ind_beg(algo::Attr_curs, attr, in_str) {
8851 retval = retval && SclDeltaOpt_ReadFieldMaybe(parent, attr.name, attr.value);
8852 }ind_end;
8853 return retval;
8854}
8855
8856// --- fasttest.SclDeltaOpt..Print
8857// print string representation of ROW to string STR
8858// cfmt:fasttest.SclDeltaOpt.String printfmt:Tuple
8859void fasttest::SclDeltaOpt_Print(fasttest::SclDeltaOpt& row, algo::cstring& str) {
8860 algo::tempstr temp;
8861 str << "fasttest.SclDeltaOpt";
8862
8863 if (Value83_PresentQ(row)) {
8864 algo::Decimal_Print(row.Value83, temp);
8865 PrintAttrSpaceReset(str,"Value83", temp);
8866 }
8867}
8868
8869// --- fasttest.SclDeltaOpt..FastEncode
8870void fasttest::SclDeltaOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDeltaOpt& parent) {
8871 int index = ary_N(buf);
8872 u64 pmap(0);
8873 if (!tid_AssignedQ(state) || parent.id != state.tid) {
8874 lib_fast::EncodeUnsigned(buf,parent.id,false);
8875 lib_fast::SetPmapBit(pmap,0);
8876 }
8877 tid_SetAssigned(state);
8878 state.tid = parent.id;
8879 // Value83 scaled delta optional
8880 if (!Value83_AssignedQ(state)) {
8881 Value83_SetAssigned(state);
8882 present_qSetBitVal(state,Value83_Present_GetBit(state),Value83_PresentQ(parent));
8883 state.Value83 = algo::Decimal(1,-83);
8884 }
8885 if (Value83_PresentQ(parent)) {
8886 if (!Value83_PresentQ(state)) {
8887 state.Value83 = algo::Decimal(1,-83);
8888 }
8889 lib_fast::EncodeDeltaScaled(buf,state.Value83,parent.Value83,true);
8890 } else {
8891 lib_fast::EncodeNull(buf);
8892 }
8893 state.Value83 = parent.Value83;
8894 present_qSetBitVal(state,Value83_Present_GetBit(state),Value83_PresentQ(parent));
8895 lib_fast::InsertPmap(buf,index,pmap);
8896}
8897
8898// --- fasttest.SclDeltaOpt..FastDecode
8899bool fasttest::SclDeltaOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDeltaOpt& parent) {
8900 bool ok = true;
8901 // Value83 scaled delta optional
8902 if (ok) {
8903 if (!Value83_AssignedQ(state)) {
8904 Value83_SetAssigned(state);
8905 bool prs(true);
8906 present_qSetBitVal(state,Value83_Present_GetBit(state),prs);
8907 state.Value83 = algo::Decimal(1,-83);
8908 }
8909 bool prs = !lib_fast::DecodeNull(from);
8910 if (prs) {
8911 if (!Value83_PresentQ(state)) {
8912 state.Value83 = algo::Decimal(1,-83);
8913 }
8914 ok = lib_fast::DecodeDeltaScaled(from,state.Value83,parent.Value83,true);
8915 if (!ok) {
8916 state.error << "fasttest.SclDeltaOpt.Value83: bad Scaled delta" << eol;
8917 }
8918 state.Value83 = parent.Value83;
8919 }
8920 pmask_qSetBitVal(parent,Value83_Present_GetBit(parent),prs);
8921 present_qSetBitVal(state,Value83_Present_GetBit(state),prs);
8922 }
8923 (void)pmap;//only to avoid -Wunused-parameter
8924 return ok;
8925}
8926
8927// --- fasttest.SclDeltaOpt..FixEncode
8928void fasttest::SclDeltaOpt_FixEncode(cstring& buf, fasttest::SclDeltaOpt& parent, char soh) {
8929 if (Value83_PresentQ(parent)) {
8930 buf << "1=" << parent.Value83 << soh;
8931 }
8932}
8933
8934// --- fasttest.SclDflt.base.CopyOut
8935// Copy fields out of row
8936void fasttest::parent_CopyOut(fasttest::SclDflt &row, fasttest::TemplateHeader &out) {
8937 // length: field value is computed
8938 // id: field value is computed
8939 (void)row;//only to avoid -Wunused-parameter
8940 (void)out;//only to avoid -Wunused-parameter
8941}
8942
8943// --- fasttest.SclDflt..ReadFieldMaybe
8944bool fasttest::SclDflt_ReadFieldMaybe(fasttest::SclDflt& parent, algo::strptr field, algo::strptr strval) {
8945 bool retval = true;
8946 fasttest::FieldId field_id;
8947 (void)value_SetStrptrMaybe(field_id,field);
8948 switch(field_id) {
8949 case fasttest_FieldId_base: {
8950 retval = false;
8951 break;
8952 }
8953 case fasttest_FieldId_length: {
8954 retval = false;
8955 break;
8956 }
8957 case fasttest_FieldId_id: {
8958 retval = false;
8959 break;
8960 }
8961 case fasttest_FieldId_Value: {
8962 retval = algo::Decimal_ReadStrptrMaybe(parent.Value, strval);
8963 break;
8964 }
8965 default: break;
8966 }
8967 if (!retval) {
8968 algo_lib::AppendErrtext("attr",field);
8969 }
8970 return retval;
8971}
8972
8973// --- fasttest.SclDflt..ReadStrptrMaybe
8974// Read fields of fasttest::SclDflt from an ascii string.
8975// The format of the string is an ssim Tuple
8976bool fasttest::SclDflt_ReadStrptrMaybe(fasttest::SclDflt &parent, algo::strptr in_str) {
8977 bool retval = true;
8978 retval = algo::StripTypeTag(in_str, "fasttest.SclDflt");
8979 ind_beg(algo::Attr_curs, attr, in_str) {
8980 retval = retval && SclDflt_ReadFieldMaybe(parent, attr.name, attr.value);
8981 }ind_end;
8982 return retval;
8983}
8984
8985// --- fasttest.SclDflt..Print
8986// print string representation of ROW to string STR
8987// cfmt:fasttest.SclDflt.String printfmt:Tuple
8988void fasttest::SclDflt_Print(fasttest::SclDflt& row, algo::cstring& str) {
8989 algo::tempstr temp;
8990 str << "fasttest.SclDflt";
8991
8992 algo::Decimal_Print(row.Value, temp);
8993 PrintAttrSpaceReset(str,"Value", temp);
8994}
8995
8996// --- fasttest.SclDflt..FastEncode
8997void fasttest::SclDflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDflt& parent) {
8998 int index = ary_N(buf);
8999 u64 pmap(0);
9000 if (!tid_AssignedQ(state) || parent.id != state.tid) {
9001 lib_fast::EncodeUnsigned(buf,parent.id,false);
9002 lib_fast::SetPmapBit(pmap,0);
9003 }
9004 tid_SetAssigned(state);
9005 state.tid = parent.id;
9006 // Value scaled default mandatory
9007 if (parent.Value != algo::Decimal(-2,-45)) {
9008 lib_fast::EncodeScaled(buf,parent.Value,false);
9009 lib_fast::SetPmapBit(pmap,1);
9010 }
9011 lib_fast::InsertPmap(buf,index,pmap);
9012}
9013
9014// --- fasttest.SclDflt..FastDecode
9015bool fasttest::SclDflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDflt& parent) {
9016 bool ok = true;
9017 // Value scaled default mandatory
9018 if (ok) {
9019 bool prs = lib_fast::GetPmapBit(pmap,1);
9020 if (prs) {
9021 ok = lib_fast::DecodeScaled(from,parent.Value,false);
9022 if (!ok) {
9023 state.error << "fasttest.SclDflt.Value: bad Scaled" << eol;
9024 }
9025 } else {
9026 parent.Value = algo::Decimal(-2,-45);
9027 }
9028 }
9029 return ok;
9030}
9031
9032// --- fasttest.SclDflt..FixEncode
9033void fasttest::SclDflt_FixEncode(cstring& buf, fasttest::SclDflt& parent, char soh) {
9034 buf << "1=" << parent.Value << soh;
9035}
9036
9037// --- fasttest.SclDfltNull.base.CopyOut
9038// Copy fields out of row
9039void fasttest::parent_CopyOut(fasttest::SclDfltNull &row, fasttest::TemplateHeader &out) {
9040 // length: field value is computed
9041 // id: field value is computed
9042 (void)row;//only to avoid -Wunused-parameter
9043 (void)out;//only to avoid -Wunused-parameter
9044}
9045
9046// --- fasttest.SclDfltNull.Value.ReadStrptrMaybe
9047inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::SclDfltNull &parent, algo::strptr in_str) {
9048 bool retval = true;
9049 algo::Decimal Value_tmp;
9050 retval = algo::Decimal_ReadStrptrMaybe(Value_tmp, in_str);
9051 if (retval) {
9052 Value_Set(parent, Value_tmp);
9053 }
9054 return retval;
9055}
9056
9057// --- fasttest.SclDfltNull.pmask_bitcurs.Next
9058// proceed to next item
9059void fasttest::SclDfltNull_pmask_bitcurs_Next(SclDfltNull_pmask_bitcurs &curs) {
9060 ++curs.bit;
9061 int index = curs.bit / 32;
9062 int offset = curs.bit % 32;
9063 for (; index < curs.n_elems; ++index, offset = 0) {
9064 u64 rest = curs.elems[index] >> offset;
9065 if (rest) {
9066 offset += algo::u64_BitScanForward(rest);
9067 break;
9068 }
9069 }
9070 curs.bit = index * 32 + offset;
9071}
9072
9073// --- fasttest.SclDfltNull..ReadFieldMaybe
9074bool fasttest::SclDfltNull_ReadFieldMaybe(fasttest::SclDfltNull& parent, algo::strptr field, algo::strptr strval) {
9075 bool retval = true;
9076 fasttest::FieldId field_id;
9077 (void)value_SetStrptrMaybe(field_id,field);
9078 switch(field_id) {
9079 case fasttest_FieldId_base: {
9080 retval = false;
9081 break;
9082 }
9083 case fasttest_FieldId_length: {
9084 retval = false;
9085 break;
9086 }
9087 case fasttest_FieldId_id: {
9088 retval = false;
9089 break;
9090 }
9091 case fasttest_FieldId_pmask: {
9092 retval = false;
9093 break;
9094 }
9095 case fasttest_FieldId_Value: {
9096 retval = Value_ReadStrptrMaybe(parent, strval);
9097 if (retval) {
9098 pmask_qSetBit(parent, 0);
9099 }
9100 break;
9101 }
9102 default: break;
9103 }
9104 if (!retval) {
9105 algo_lib::AppendErrtext("attr",field);
9106 }
9107 return retval;
9108}
9109
9110// --- fasttest.SclDfltNull..ReadStrptrMaybe
9111// Read fields of fasttest::SclDfltNull from an ascii string.
9112// The format of the string is an ssim Tuple
9113bool fasttest::SclDfltNull_ReadStrptrMaybe(fasttest::SclDfltNull &parent, algo::strptr in_str) {
9114 bool retval = true;
9115 retval = algo::StripTypeTag(in_str, "fasttest.SclDfltNull");
9116 ind_beg(algo::Attr_curs, attr, in_str) {
9117 retval = retval && SclDfltNull_ReadFieldMaybe(parent, attr.name, attr.value);
9118 }ind_end;
9119 return retval;
9120}
9121
9122// --- fasttest.SclDfltNull..Print
9123// print string representation of ROW to string STR
9124// cfmt:fasttest.SclDfltNull.String printfmt:Tuple
9125void fasttest::SclDfltNull_Print(fasttest::SclDfltNull& row, algo::cstring& str) {
9126 algo::tempstr temp;
9127 str << "fasttest.SclDfltNull";
9128
9129 if (Value_PresentQ(row)) {
9130 algo::Decimal_Print(row.Value, temp);
9131 PrintAttrSpaceReset(str,"Value", temp);
9132 }
9133}
9134
9135// --- fasttest.SclDfltNull..FastEncode
9136void fasttest::SclDfltNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDfltNull& parent) {
9137 int index = ary_N(buf);
9138 u64 pmap(0);
9139 if (!tid_AssignedQ(state) || parent.id != state.tid) {
9140 lib_fast::EncodeUnsigned(buf,parent.id,false);
9141 lib_fast::SetPmapBit(pmap,0);
9142 }
9143 tid_SetAssigned(state);
9144 state.tid = parent.id;
9145 // Value scaled default optional
9146 if (Value_PresentQ(parent)) {
9147 if (parent.Value != algo::Decimal(0,0)) {
9148 lib_fast::EncodeScaled(buf,parent.Value,true);
9149 lib_fast::SetPmapBit(pmap,1);
9150 }
9151 } else {
9152 lib_fast::EncodeNull(buf);
9153 lib_fast::SetPmapBit(pmap,1);
9154 }
9155 lib_fast::InsertPmap(buf,index,pmap);
9156}
9157
9158// --- fasttest.SclDfltNull..FastDecode
9159bool fasttest::SclDfltNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDfltNull& parent) {
9160 bool ok = true;
9161 // Value scaled default optional
9162 if (ok) {
9163 bool prs = lib_fast::GetPmapBit(pmap,1);
9164 if (prs) {
9165 prs = !lib_fast::DecodeNull(from);
9166 if (prs) {
9167 ok = lib_fast::DecodeScaled(from,parent.Value,true);
9168 if (!ok) {
9169 state.error << "fasttest.SclDfltNull.Value: bad Scaled" << eol;
9170 }
9171 }
9172 } else {
9173 parent.Value = algo::Decimal(0,0);
9174 prs = true;
9175 }
9176 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
9177 }
9178 return ok;
9179}
9180
9181// --- fasttest.SclDfltNull..FixEncode
9182void fasttest::SclDfltNull_FixEncode(cstring& buf, fasttest::SclDfltNull& parent, char soh) {
9183 if (Value_PresentQ(parent)) {
9184 buf << "1=" << parent.Value << soh;
9185 }
9186}
9187
9188// --- fasttest.SclDfltOpt.base.CopyOut
9189// Copy fields out of row
9190void fasttest::parent_CopyOut(fasttest::SclDfltOpt &row, fasttest::TemplateHeader &out) {
9191 // length: field value is computed
9192 // id: field value is computed
9193 (void)row;//only to avoid -Wunused-parameter
9194 (void)out;//only to avoid -Wunused-parameter
9195}
9196
9197// --- fasttest.SclDfltOpt.Value.ReadStrptrMaybe
9198inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::SclDfltOpt &parent, algo::strptr in_str) {
9199 bool retval = true;
9200 algo::Decimal Value_tmp;
9201 retval = algo::Decimal_ReadStrptrMaybe(Value_tmp, in_str);
9202 if (retval) {
9203 Value_Set(parent, Value_tmp);
9204 }
9205 return retval;
9206}
9207
9208// --- fasttest.SclDfltOpt.pmask_bitcurs.Next
9209// proceed to next item
9210void fasttest::SclDfltOpt_pmask_bitcurs_Next(SclDfltOpt_pmask_bitcurs &curs) {
9211 ++curs.bit;
9212 int index = curs.bit / 32;
9213 int offset = curs.bit % 32;
9214 for (; index < curs.n_elems; ++index, offset = 0) {
9215 u64 rest = curs.elems[index] >> offset;
9216 if (rest) {
9217 offset += algo::u64_BitScanForward(rest);
9218 break;
9219 }
9220 }
9221 curs.bit = index * 32 + offset;
9222}
9223
9224// --- fasttest.SclDfltOpt..ReadFieldMaybe
9225bool fasttest::SclDfltOpt_ReadFieldMaybe(fasttest::SclDfltOpt& parent, algo::strptr field, algo::strptr strval) {
9226 bool retval = true;
9227 fasttest::FieldId field_id;
9228 (void)value_SetStrptrMaybe(field_id,field);
9229 switch(field_id) {
9230 case fasttest_FieldId_base: {
9231 retval = false;
9232 break;
9233 }
9234 case fasttest_FieldId_length: {
9235 retval = false;
9236 break;
9237 }
9238 case fasttest_FieldId_id: {
9239 retval = false;
9240 break;
9241 }
9242 case fasttest_FieldId_pmask: {
9243 retval = false;
9244 break;
9245 }
9246 case fasttest_FieldId_Value: {
9247 retval = Value_ReadStrptrMaybe(parent, strval);
9248 if (retval) {
9249 pmask_qSetBit(parent, 0);
9250 }
9251 break;
9252 }
9253 default: break;
9254 }
9255 if (!retval) {
9256 algo_lib::AppendErrtext("attr",field);
9257 }
9258 return retval;
9259}
9260
9261// --- fasttest.SclDfltOpt..ReadStrptrMaybe
9262// Read fields of fasttest::SclDfltOpt from an ascii string.
9263// The format of the string is an ssim Tuple
9264bool fasttest::SclDfltOpt_ReadStrptrMaybe(fasttest::SclDfltOpt &parent, algo::strptr in_str) {
9265 bool retval = true;
9266 retval = algo::StripTypeTag(in_str, "fasttest.SclDfltOpt");
9267 ind_beg(algo::Attr_curs, attr, in_str) {
9268 retval = retval && SclDfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
9269 }ind_end;
9270 return retval;
9271}
9272
9273// --- fasttest.SclDfltOpt..Print
9274// print string representation of ROW to string STR
9275// cfmt:fasttest.SclDfltOpt.String printfmt:Tuple
9276void fasttest::SclDfltOpt_Print(fasttest::SclDfltOpt& row, algo::cstring& str) {
9277 algo::tempstr temp;
9278 str << "fasttest.SclDfltOpt";
9279
9280 if (Value_PresentQ(row)) {
9281 algo::Decimal_Print(row.Value, temp);
9282 PrintAttrSpaceReset(str,"Value", temp);
9283 }
9284}
9285
9286// --- fasttest.SclDfltOpt..FastEncode
9287void fasttest::SclDfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclDfltOpt& parent) {
9288 int index = ary_N(buf);
9289 u64 pmap(0);
9290 if (!tid_AssignedQ(state) || parent.id != state.tid) {
9291 lib_fast::EncodeUnsigned(buf,parent.id,false);
9292 lib_fast::SetPmapBit(pmap,0);
9293 }
9294 tid_SetAssigned(state);
9295 state.tid = parent.id;
9296 // Value scaled default optional
9297 if (Value_PresentQ(parent)) {
9298 if (parent.Value != algo::Decimal(1,-46)) {
9299 lib_fast::EncodeScaled(buf,parent.Value,true);
9300 lib_fast::SetPmapBit(pmap,1);
9301 }
9302 } else {
9303 lib_fast::EncodeNull(buf);
9304 lib_fast::SetPmapBit(pmap,1);
9305 }
9306 lib_fast::InsertPmap(buf,index,pmap);
9307}
9308
9309// --- fasttest.SclDfltOpt..FastDecode
9310bool fasttest::SclDfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclDfltOpt& parent) {
9311 bool ok = true;
9312 // Value scaled default optional
9313 if (ok) {
9314 bool prs = lib_fast::GetPmapBit(pmap,1);
9315 if (prs) {
9316 prs = !lib_fast::DecodeNull(from);
9317 if (prs) {
9318 ok = lib_fast::DecodeScaled(from,parent.Value,true);
9319 if (!ok) {
9320 state.error << "fasttest.SclDfltOpt.Value: bad Scaled" << eol;
9321 }
9322 }
9323 } else {
9324 parent.Value = algo::Decimal(1,-46);
9325 prs = true;
9326 }
9327 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
9328 }
9329 return ok;
9330}
9331
9332// --- fasttest.SclDfltOpt..FixEncode
9333void fasttest::SclDfltOpt_FixEncode(cstring& buf, fasttest::SclDfltOpt& parent, char soh) {
9334 if (Value_PresentQ(parent)) {
9335 buf << "1=" << parent.Value << soh;
9336 }
9337}
9338
9339// --- fasttest.SclNone.base.CopyOut
9340// Copy fields out of row
9341void fasttest::parent_CopyOut(fasttest::SclNone &row, fasttest::TemplateHeader &out) {
9342 // length: field value is computed
9343 // id: field value is computed
9344 (void)row;//only to avoid -Wunused-parameter
9345 (void)out;//only to avoid -Wunused-parameter
9346}
9347
9348// --- fasttest.SclNone..ReadFieldMaybe
9349bool fasttest::SclNone_ReadFieldMaybe(fasttest::SclNone& parent, algo::strptr field, algo::strptr strval) {
9350 bool retval = true;
9351 fasttest::FieldId field_id;
9352 (void)value_SetStrptrMaybe(field_id,field);
9353 switch(field_id) {
9354 case fasttest_FieldId_base: {
9355 retval = false;
9356 break;
9357 }
9358 case fasttest_FieldId_length: {
9359 retval = false;
9360 break;
9361 }
9362 case fasttest_FieldId_id: {
9363 retval = false;
9364 break;
9365 }
9366 case fasttest_FieldId_Value: {
9367 retval = algo::Decimal_ReadStrptrMaybe(parent.Value, strval);
9368 break;
9369 }
9370 default: break;
9371 }
9372 if (!retval) {
9373 algo_lib::AppendErrtext("attr",field);
9374 }
9375 return retval;
9376}
9377
9378// --- fasttest.SclNone..ReadStrptrMaybe
9379// Read fields of fasttest::SclNone from an ascii string.
9380// The format of the string is an ssim Tuple
9381bool fasttest::SclNone_ReadStrptrMaybe(fasttest::SclNone &parent, algo::strptr in_str) {
9382 bool retval = true;
9383 retval = algo::StripTypeTag(in_str, "fasttest.SclNone");
9384 ind_beg(algo::Attr_curs, attr, in_str) {
9385 retval = retval && SclNone_ReadFieldMaybe(parent, attr.name, attr.value);
9386 }ind_end;
9387 return retval;
9388}
9389
9390// --- fasttest.SclNone..Print
9391// print string representation of ROW to string STR
9392// cfmt:fasttest.SclNone.String printfmt:Tuple
9393void fasttest::SclNone_Print(fasttest::SclNone& row, algo::cstring& str) {
9394 algo::tempstr temp;
9395 str << "fasttest.SclNone";
9396
9397 algo::Decimal_Print(row.Value, temp);
9398 PrintAttrSpaceReset(str,"Value", temp);
9399}
9400
9401// --- fasttest.SclNone..FastEncode
9402void fasttest::SclNone_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclNone& parent) {
9403 int index = ary_N(buf);
9404 u64 pmap(0);
9405 if (!tid_AssignedQ(state) || parent.id != state.tid) {
9406 lib_fast::EncodeUnsigned(buf,parent.id,false);
9407 lib_fast::SetPmapBit(pmap,0);
9408 }
9409 tid_SetAssigned(state);
9410 state.tid = parent.id;
9411 // Value scaled none mandatory
9412 lib_fast::EncodeScaled(buf,parent.Value,false);
9413 lib_fast::InsertPmap(buf,index,pmap);
9414}
9415
9416// --- fasttest.SclNone..FastDecode
9417bool fasttest::SclNone_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclNone& parent) {
9418 bool ok = true;
9419 // Value scaled none mandatory
9420 if (ok) {
9421 ok = lib_fast::DecodeScaled(from,parent.Value,false);
9422 if (!ok) {
9423 state.error << "fasttest.SclNone.Value: bad Scaled" << eol;
9424 }
9425 }
9426 (void)pmap;//only to avoid -Wunused-parameter
9427 return ok;
9428}
9429
9430// --- fasttest.SclNone..FixEncode
9431void fasttest::SclNone_FixEncode(cstring& buf, fasttest::SclNone& parent, char soh) {
9432 buf << "1=" << parent.Value << soh;
9433}
9434
9435// --- fasttest.SclNoneOpt.base.CopyOut
9436// Copy fields out of row
9437void fasttest::parent_CopyOut(fasttest::SclNoneOpt &row, fasttest::TemplateHeader &out) {
9438 // length: field value is computed
9439 // id: field value is computed
9440 (void)row;//only to avoid -Wunused-parameter
9441 (void)out;//only to avoid -Wunused-parameter
9442}
9443
9444// --- fasttest.SclNoneOpt.Value.ReadStrptrMaybe
9445inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::SclNoneOpt &parent, algo::strptr in_str) {
9446 bool retval = true;
9447 algo::Decimal Value_tmp;
9448 retval = algo::Decimal_ReadStrptrMaybe(Value_tmp, in_str);
9449 if (retval) {
9450 Value_Set(parent, Value_tmp);
9451 }
9452 return retval;
9453}
9454
9455// --- fasttest.SclNoneOpt.pmask_bitcurs.Next
9456// proceed to next item
9457void fasttest::SclNoneOpt_pmask_bitcurs_Next(SclNoneOpt_pmask_bitcurs &curs) {
9458 ++curs.bit;
9459 int index = curs.bit / 32;
9460 int offset = curs.bit % 32;
9461 for (; index < curs.n_elems; ++index, offset = 0) {
9462 u64 rest = curs.elems[index] >> offset;
9463 if (rest) {
9464 offset += algo::u64_BitScanForward(rest);
9465 break;
9466 }
9467 }
9468 curs.bit = index * 32 + offset;
9469}
9470
9471// --- fasttest.SclNoneOpt..ReadFieldMaybe
9472bool fasttest::SclNoneOpt_ReadFieldMaybe(fasttest::SclNoneOpt& parent, algo::strptr field, algo::strptr strval) {
9473 bool retval = true;
9474 fasttest::FieldId field_id;
9475 (void)value_SetStrptrMaybe(field_id,field);
9476 switch(field_id) {
9477 case fasttest_FieldId_base: {
9478 retval = false;
9479 break;
9480 }
9481 case fasttest_FieldId_length: {
9482 retval = false;
9483 break;
9484 }
9485 case fasttest_FieldId_id: {
9486 retval = false;
9487 break;
9488 }
9489 case fasttest_FieldId_pmask: {
9490 retval = false;
9491 break;
9492 }
9493 case fasttest_FieldId_Value: {
9494 retval = Value_ReadStrptrMaybe(parent, strval);
9495 if (retval) {
9496 pmask_qSetBit(parent, 0);
9497 }
9498 break;
9499 }
9500 default: break;
9501 }
9502 if (!retval) {
9503 algo_lib::AppendErrtext("attr",field);
9504 }
9505 return retval;
9506}
9507
9508// --- fasttest.SclNoneOpt..ReadStrptrMaybe
9509// Read fields of fasttest::SclNoneOpt from an ascii string.
9510// The format of the string is an ssim Tuple
9511bool fasttest::SclNoneOpt_ReadStrptrMaybe(fasttest::SclNoneOpt &parent, algo::strptr in_str) {
9512 bool retval = true;
9513 retval = algo::StripTypeTag(in_str, "fasttest.SclNoneOpt");
9514 ind_beg(algo::Attr_curs, attr, in_str) {
9515 retval = retval && SclNoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
9516 }ind_end;
9517 return retval;
9518}
9519
9520// --- fasttest.SclNoneOpt..Print
9521// print string representation of ROW to string STR
9522// cfmt:fasttest.SclNoneOpt.String printfmt:Tuple
9523void fasttest::SclNoneOpt_Print(fasttest::SclNoneOpt& row, algo::cstring& str) {
9524 algo::tempstr temp;
9525 str << "fasttest.SclNoneOpt";
9526
9527 if (Value_PresentQ(row)) {
9528 algo::Decimal_Print(row.Value, temp);
9529 PrintAttrSpaceReset(str,"Value", temp);
9530 }
9531}
9532
9533// --- fasttest.SclNoneOpt..FastEncode
9534void fasttest::SclNoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SclNoneOpt& parent) {
9535 int index = ary_N(buf);
9536 u64 pmap(0);
9537 if (!tid_AssignedQ(state) || parent.id != state.tid) {
9538 lib_fast::EncodeUnsigned(buf,parent.id,false);
9539 lib_fast::SetPmapBit(pmap,0);
9540 }
9541 tid_SetAssigned(state);
9542 state.tid = parent.id;
9543 // Value scaled none optional
9544 if (Value_PresentQ(parent)) {
9545 lib_fast::EncodeScaled(buf,parent.Value,true);
9546 } else {
9547 lib_fast::EncodeNull(buf);
9548 }
9549 lib_fast::InsertPmap(buf,index,pmap);
9550}
9551
9552// --- fasttest.SclNoneOpt..FastDecode
9553bool fasttest::SclNoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SclNoneOpt& parent) {
9554 bool ok = true;
9555 // Value scaled none optional
9556 if (ok) {
9557 bool prs = !lib_fast::DecodeNull(from);
9558 if (prs) {
9559 ok = lib_fast::DecodeScaled(from,parent.Value,true);
9560 if (!ok) {
9561 state.error << "fasttest.SclNoneOpt.Value: bad Scaled" << eol;
9562 }
9563 }
9564 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
9565 }
9566 (void)pmap;//only to avoid -Wunused-parameter
9567 return ok;
9568}
9569
9570// --- fasttest.SclNoneOpt..FixEncode
9571void fasttest::SclNoneOpt_FixEncode(cstring& buf, fasttest::SclNoneOpt& parent, char soh) {
9572 if (Value_PresentQ(parent)) {
9573 buf << "1=" << parent.Value << soh;
9574 }
9575}
9576
9577// --- fasttest.SecondSeq..ReadFieldMaybe
9578bool fasttest::SecondSeq_ReadFieldMaybe(fasttest::SecondSeq& parent, algo::strptr field, algo::strptr strval) {
9579 bool retval = true;
9580 fasttest::FieldId field_id;
9581 (void)value_SetStrptrMaybe(field_id,field);
9582 switch(field_id) {
9583 case fasttest_FieldId_Value2: {
9584 retval = u32_ReadStrptrMaybe(parent.Value2, strval);
9585 break;
9586 }
9587 default: break;
9588 }
9589 if (!retval) {
9590 algo_lib::AppendErrtext("attr",field);
9591 }
9592 return retval;
9593}
9594
9595// --- fasttest.SecondSeq..ReadStrptrMaybe
9596// Read fields of fasttest::SecondSeq from an ascii string.
9597// The format of the string is an ssim Tuple
9598bool fasttest::SecondSeq_ReadStrptrMaybe(fasttest::SecondSeq &parent, algo::strptr in_str) {
9599 bool retval = true;
9600 retval = algo::StripTypeTag(in_str, "fasttest.SecondSeq");
9601 ind_beg(algo::Attr_curs, attr, in_str) {
9602 retval = retval && SecondSeq_ReadFieldMaybe(parent, attr.name, attr.value);
9603 }ind_end;
9604 return retval;
9605}
9606
9607// --- fasttest.SecondSeq..Print
9608// print string representation of ROW to string STR
9609// cfmt:fasttest.SecondSeq.String printfmt:Tuple
9610void fasttest::SecondSeq_Print(fasttest::SecondSeq& row, algo::cstring& str) {
9611 algo::tempstr temp;
9612 str << "fasttest.SecondSeq";
9613
9614 u32_Print(row.Value2, temp);
9615 PrintAttrSpaceReset(str,"Value2", temp);
9616}
9617
9618// --- fasttest.SecondSeq..FastEncode
9619void fasttest::SecondSeq_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SecondSeq& parent) {
9620 // Value2 unsigned none mandatory
9621 lib_fast::EncodeUnsigned(buf,parent.Value2,false);
9622 (void)state;//only to avoid -Wunused-parameter
9623}
9624
9625// --- fasttest.SecondSeq..FastDecode
9626bool fasttest::SecondSeq_FastDecode(algo::memptr& from, FastState& state, fasttest::SecondSeq& parent) {
9627 bool ok = true;
9628 // Value2 unsigned none mandatory
9629 if (ok) {
9630 ok = lib_fast::DecodeUnsigned(from,parent.Value2,false);
9631 if (!ok) {
9632 state.error << "fasttest.SecondSeq.Value2: bad Unsigned" << eol;
9633 }
9634 }
9635 return ok;
9636}
9637
9638// --- fasttest.SecondSeq..FixEncode
9639void fasttest::SecondSeq_FixEncode(cstring& buf, fasttest::SecondSeq& parent, char soh) {
9640 buf << "5=" << parent.Value2 << soh;
9641}
9642
9643// --- fasttest.SeqOrder.base.CopyOut
9644// Copy fields out of row
9645void fasttest::parent_CopyOut(fasttest::SeqOrder &row, fasttest::TemplateHeader &out) {
9646 // length: field value is computed
9647 // id: field value is computed
9648 (void)row;//only to avoid -Wunused-parameter
9649 (void)out;//only to avoid -Wunused-parameter
9650}
9651
9652// --- fasttest.SeqOrder.FirstSeq.Getary
9653// Access var-length portion as an aryptr. Length is determined from one of the fields.
9654algo::aryptr<fasttest::FirstSeq> fasttest::FirstSeq_Getary(fasttest::SeqOrder& parent) {
9655 return algo::aryptr<fasttest::FirstSeq>(FirstSeq_Addr(parent), FirstSeq_N(parent));
9656}
9657
9658// --- fasttest.SeqOrder.FirstSeq.Addr
9659fasttest::FirstSeq* fasttest::FirstSeq_Addr(fasttest::SeqOrder& parent) {
9660 return (fasttest::FirstSeq*)((u8*)&parent + sizeof(fasttest::SeqOrder)); // address of varlen portion
9661}
9662
9663// --- fasttest.SeqOrder.FirstSeq.ReadStrptrMaybe
9664// Convert string to field. Return success value
9665bool fasttest::FirstSeq_ReadStrptrMaybe(fasttest::SeqOrder& parent, algo::strptr in_str) {
9666 bool retval = true;
9667 if (algo_lib::_db.varlenbuf) {
9668 fasttest::FirstSeq *FirstSeq_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::FirstSeq)).elems) fasttest::FirstSeq;
9669 retval = fasttest::FirstSeq_ReadStrptrMaybe(*FirstSeq_tmp, in_str);
9670 }
9671 (void)parent;//only to avoid -Wunused-parameter
9672 return retval;
9673}
9674
9675// --- fasttest.SeqOrder..ReadFieldMaybe
9676bool fasttest::SeqOrder_ReadFieldMaybe(fasttest::SeqOrder& parent, algo::strptr field, algo::strptr strval) {
9677 bool retval = true;
9678 fasttest::FieldId field_id;
9679 (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
9680 switch(field_id) {
9681 case fasttest_FieldId_base: {
9682 retval = false;
9683 break;
9684 }
9685 case fasttest_FieldId_length: {
9686 retval = false;
9687 break;
9688 }
9689 case fasttest_FieldId_id: {
9690 retval = false;
9691 break;
9692 }
9693 case fasttest_FieldId_SecondSeq: {
9694 retval = fasttest::SecondSeq_ReadStrptrMaybe(parent.SecondSeq, strval);
9695 break;
9696 }
9697 case fasttest_FieldId_Value3: {
9698 retval = u32_ReadStrptrMaybe(parent.Value3, strval);
9699 break;
9700 }
9701 case fasttest_FieldId_FirstSeq: {
9702 retval = FirstSeq_ReadStrptrMaybe(parent, strval);
9703 break;
9704 }
9705 default: break;
9706 }
9707 if (!retval) {
9708 algo_lib::AppendErrtext("attr",field);
9709 }
9710 return retval;
9711}
9712
9713// --- fasttest.SeqOrder..ReadStrptrMaybe
9714// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
9715// Read fields of fasttest::SeqOrder from an ascii string.
9716// The format of the string is an ssim Tuple
9717bool fasttest::SeqOrder_ReadStrptrMaybe(fasttest::SeqOrder &parent, algo::strptr in_str) {
9718 bool retval = true;
9719 retval = algo::StripTypeTag(in_str, "fasttest.SeqOrder");
9720 ind_beg(algo::Attr_curs, attr, in_str) {
9721 retval = retval && SeqOrder_ReadFieldMaybe(parent, attr.name, attr.value);
9722 }ind_end;
9723 return retval;
9724}
9725
9726// --- fasttest.SeqOrder..Print
9727// print string representation of ROW to string STR
9728// cfmt:fasttest.SeqOrder.String printfmt:Tuple
9729void fasttest::SeqOrder_Print(fasttest::SeqOrder& row, algo::cstring& str) {
9730 algo::tempstr temp;
9731 str << "fasttest.SeqOrder";
9732
9733 fasttest::SecondSeq_Print(row.SecondSeq, temp);
9734 PrintAttrSpaceReset(str,"SecondSeq", temp);
9735
9736 u32_Print(row.Value3, temp);
9737 PrintAttrSpaceReset(str,"Value3", temp);
9738
9739 ind_beg(SeqOrder_FirstSeq_curs,FirstSeq,row) {
9740 fasttest::FirstSeq_Print(FirstSeq, temp);
9741 tempstr name;
9742 name << "FirstSeq.";
9743 name << ind_curs(FirstSeq).index;
9744 PrintAttrSpaceReset(str, name, temp);
9745 }ind_end;
9746}
9747
9748// --- fasttest.SeqOrder..FastEncode
9749void fasttest::SeqOrder_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqOrder& parent) {
9750 int index = ary_N(buf);
9751 u64 pmap(0);
9752 if (!tid_AssignedQ(state) || parent.id != state.tid) {
9753 lib_fast::EncodeUnsigned(buf,parent.id,false);
9754 lib_fast::SetPmapBit(pmap,0);
9755 }
9756 tid_SetAssigned(state);
9757 state.tid = parent.id;
9758 // FirstSeq sequence none mandatory
9759 {
9760 u32 length = FirstSeq_N(parent);
9761 lib_fast::EncodeUnsigned(buf,length,false);
9762 ind_beg(SeqOrder_FirstSeq_curs,elem,parent) {
9763 FirstSeq_FastEncode(buf,state,elem);
9764 }ind_end;
9765 }
9766 // SecondSeq sequence none mandatory
9767 SecondSeq_FastEncode(buf,state,parent.SecondSeq);
9768 // Value3 unsigned none mandatory
9769 lib_fast::EncodeUnsigned(buf,parent.Value3,false);
9770 lib_fast::InsertPmap(buf,index,pmap);
9771}
9772
9773// --- fasttest.SeqOrder..FastDecode
9774bool fasttest::SeqOrder_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqOrder& parent) {
9775 bool ok = true;
9776 // FirstSeq sequence none mandatory
9777 if (ok) {
9778 u32 length(0);
9779 ok = lib_fast::DecodeUnsigned(from,length,false);
9780 if (!ok) {
9781 state.error << "fasttest.SeqOrder.FirstSeq: bad Unsigned" << eol;
9782 }
9783 if (!ok) {
9784 state.error << "fasttest.SeqOrder.FirstSeq: bad length" << eol;
9785 }
9786 for (unsigned i=0; ok && i<length; ++i) {
9787 FirstSeq &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) FirstSeq;
9788 ok = FirstSeq_FastDecode(from,state,seq);
9789 if (!ok) {
9790 state.error << "fasttest.SeqOrder.FirstSeq: element #"<< i+1 << eol;
9791 }
9792 }
9793 }
9794 // SecondSeq sequence none mandatory
9795 if (ok) {
9796 ok = SecondSeq_FastDecode(from,state,parent.SecondSeq);
9797 }
9798 // Value3 unsigned none mandatory
9799 if (ok) {
9800 ok = lib_fast::DecodeUnsigned(from,parent.Value3,false);
9801 if (!ok) {
9802 state.error << "fasttest.SeqOrder.Value3: bad Unsigned" << eol;
9803 }
9804 }
9805 (void)pmap;//only to avoid -Wunused-parameter
9806 return ok;
9807}
9808
9809// --- fasttest.SeqOrder..FixEncode
9810void fasttest::SeqOrder_FixEncode(cstring& buf, fasttest::SeqOrder& parent, char soh) {
9811 ind_beg(SeqOrder_FirstSeq_curs,elem,parent) {
9812 FirstSeq_FixEncode(buf,elem,soh);
9813 }ind_end;
9814 buf << "4=1" << soh;
9815 buf << "3=" << parent.SecondSeq << soh;
9816 buf << "6=" << parent.Value3 << soh;
9817}
9818
9819// --- fasttest.SeqSgmOpt.base.CopyOut
9820// Copy fields out of row
9821void fasttest::parent_CopyOut(fasttest::SeqSgmOpt &row, fasttest::TemplateHeader &out) {
9822 // length: field value is computed
9823 // id: field value is computed
9824 (void)row;//only to avoid -Wunused-parameter
9825 (void)out;//only to avoid -Wunused-parameter
9826}
9827
9828// --- fasttest.SeqSgmOpt.OptSgmSeq.Getary
9829// Access var-length portion as an aryptr. Length is determined from one of the fields.
9830algo::aryptr<fasttest::OptSgmSeq> fasttest::OptSgmSeq_Getary(fasttest::SeqSgmOpt& parent) {
9831 return algo::aryptr<fasttest::OptSgmSeq>(OptSgmSeq_Addr(parent), OptSgmSeq_N(parent));
9832}
9833
9834// --- fasttest.SeqSgmOpt.OptSgmSeq.Addr
9835fasttest::OptSgmSeq* fasttest::OptSgmSeq_Addr(fasttest::SeqSgmOpt& parent) {
9836 return (fasttest::OptSgmSeq*)((u8*)&parent + sizeof(fasttest::SeqSgmOpt)); // address of varlen portion
9837}
9838
9839// --- fasttest.SeqSgmOpt.OptSgmSeq.ReadStrptrMaybe
9840// Convert string to field. Return success value
9841bool fasttest::OptSgmSeq_ReadStrptrMaybe(fasttest::SeqSgmOpt& parent, algo::strptr in_str) {
9842 bool retval = true;
9843 if (algo_lib::_db.varlenbuf) {
9844 fasttest::OptSgmSeq *OptSgmSeq_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::OptSgmSeq)).elems) fasttest::OptSgmSeq;
9845 retval = fasttest::OptSgmSeq_ReadStrptrMaybe(*OptSgmSeq_tmp, in_str);
9846 }
9847 (void)parent;//only to avoid -Wunused-parameter
9848 return retval;
9849}
9850
9851// --- fasttest.SeqSgmOpt..ReadFieldMaybe
9852bool fasttest::SeqSgmOpt_ReadFieldMaybe(fasttest::SeqSgmOpt& parent, algo::strptr field, algo::strptr strval) {
9853 bool retval = true;
9854 fasttest::FieldId field_id;
9855 (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
9856 switch(field_id) {
9857 case fasttest_FieldId_base: {
9858 retval = false;
9859 break;
9860 }
9861 case fasttest_FieldId_length: {
9862 retval = false;
9863 break;
9864 }
9865 case fasttest_FieldId_id: {
9866 retval = false;
9867 break;
9868 }
9869 case fasttest_FieldId_OptSgmSeq: {
9870 retval = OptSgmSeq_ReadStrptrMaybe(parent, strval);
9871 break;
9872 }
9873 default: break;
9874 }
9875 if (!retval) {
9876 algo_lib::AppendErrtext("attr",field);
9877 }
9878 return retval;
9879}
9880
9881// --- fasttest.SeqSgmOpt..ReadStrptrMaybe
9882// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
9883// Read fields of fasttest::SeqSgmOpt from an ascii string.
9884// The format of the string is an ssim Tuple
9885bool fasttest::SeqSgmOpt_ReadStrptrMaybe(fasttest::SeqSgmOpt &parent, algo::strptr in_str) {
9886 bool retval = true;
9887 retval = algo::StripTypeTag(in_str, "fasttest.SeqSgmOpt");
9888 ind_beg(algo::Attr_curs, attr, in_str) {
9889 retval = retval && SeqSgmOpt_ReadFieldMaybe(parent, attr.name, attr.value);
9890 }ind_end;
9891 return retval;
9892}
9893
9894// --- fasttest.SeqSgmOpt..Print
9895// print string representation of ROW to string STR
9896// cfmt:fasttest.SeqSgmOpt.String printfmt:Tuple
9897void fasttest::SeqSgmOpt_Print(fasttest::SeqSgmOpt& row, algo::cstring& str) {
9898 algo::tempstr temp;
9899 str << "fasttest.SeqSgmOpt";
9900
9901 ind_beg(SeqSgmOpt_OptSgmSeq_curs,OptSgmSeq,row) {
9902 fasttest::OptSgmSeq_Print(OptSgmSeq, temp);
9903 tempstr name;
9904 name << "OptSgmSeq.";
9905 name << ind_curs(OptSgmSeq).index;
9906 PrintAttrSpaceReset(str, name, temp);
9907 }ind_end;
9908}
9909
9910// --- fasttest.SeqSgmOpt..FastEncode
9911void fasttest::SeqSgmOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqSgmOpt& parent) {
9912 int index = ary_N(buf);
9913 u64 pmap(0);
9914 if (!tid_AssignedQ(state) || parent.id != state.tid) {
9915 lib_fast::EncodeUnsigned(buf,parent.id,false);
9916 lib_fast::SetPmapBit(pmap,0);
9917 }
9918 tid_SetAssigned(state);
9919 state.tid = parent.id;
9920 // OptSgmSeq sequence none optional
9921 {
9922 u32 length = OptSgmSeq_N(parent);
9923 if (length) {
9924 lib_fast::EncodeUnsigned(buf,length,true);
9925 } else {
9926 lib_fast::EncodeNull(buf);
9927 }
9928 ind_beg(SeqSgmOpt_OptSgmSeq_curs,elem,parent) {
9929 OptSgmSeq_FastEncode(buf,state,elem);
9930 }ind_end;
9931 }
9932 lib_fast::InsertPmap(buf,index,pmap);
9933}
9934
9935// --- fasttest.SeqSgmOpt..FastDecode
9936bool fasttest::SeqSgmOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqSgmOpt& parent) {
9937 bool ok = true;
9938 // OptSgmSeq sequence none optional
9939 if (ok) {
9940 u32 length(0);
9941 bool prs = !lib_fast::DecodeNull(from);
9942 if (prs) {
9943 ok = lib_fast::DecodeUnsigned(from,length,true);
9944 if (!ok) {
9945 state.error << "fasttest.SeqSgmOpt.OptSgmSeq: bad Unsigned" << eol;
9946 }
9947 }
9948 ;
9949 if (!ok) {
9950 state.error << "fasttest.SeqSgmOpt.OptSgmSeq: bad length" << eol;
9951 }
9952 length = prs ? length : 0;
9953 for (unsigned i=0; ok && i<length; ++i) {
9954 OptSgmSeq &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) OptSgmSeq;
9955 ok = OptSgmSeq_FastDecode(from,state,seq);
9956 if (!ok) {
9957 state.error << "fasttest.SeqSgmOpt.OptSgmSeq: element #"<< i+1 << eol;
9958 }
9959 }
9960 }
9961 (void)pmap;//only to avoid -Wunused-parameter
9962 (void)parent;//only to avoid -Wunused-parameter
9963 return ok;
9964}
9965
9966// --- fasttest.SeqSgmOpt..FixEncode
9967void fasttest::SeqSgmOpt_FixEncode(cstring& buf, fasttest::SeqSgmOpt& parent, char soh) {
9968 ind_beg(SeqSgmOpt_OptSgmSeq_curs,elem,parent) {
9969 OptSgmSeq_FixEncode(buf,elem,soh);
9970 }ind_end;
9971}
9972
9973// --- fasttest.TrvSeq..ReadFieldMaybe
9974bool fasttest::TrvSeq_ReadFieldMaybe(fasttest::TrvSeq& parent, algo::strptr field, algo::strptr strval) {
9975 bool retval = true;
9976 fasttest::FieldId field_id;
9977 (void)value_SetStrptrMaybe(field_id,field);
9978 switch(field_id) {
9979 case fasttest_FieldId_Value: {
9980 retval = u32_ReadStrptrMaybe(parent.Value, strval);
9981 break;
9982 }
9983 default: break;
9984 }
9985 if (!retval) {
9986 algo_lib::AppendErrtext("attr",field);
9987 }
9988 return retval;
9989}
9990
9991// --- fasttest.TrvSeq..ReadStrptrMaybe
9992// Read fields of fasttest::TrvSeq from an ascii string.
9993// The format of the string is an ssim Tuple
9994bool fasttest::TrvSeq_ReadStrptrMaybe(fasttest::TrvSeq &parent, algo::strptr in_str) {
9995 bool retval = true;
9996 retval = algo::StripTypeTag(in_str, "fasttest.TrvSeq");
9997 ind_beg(algo::Attr_curs, attr, in_str) {
9998 retval = retval && TrvSeq_ReadFieldMaybe(parent, attr.name, attr.value);
9999 }ind_end;
10000 return retval;
10001}
10002
10003// --- fasttest.TrvSeq..Print
10004// print string representation of ROW to string STR
10005// cfmt:fasttest.TrvSeq.String printfmt:Tuple
10006void fasttest::TrvSeq_Print(fasttest::TrvSeq& row, algo::cstring& str) {
10007 algo::tempstr temp;
10008 str << "fasttest.TrvSeq";
10009
10010 u32_Print(row.Value, temp);
10011 PrintAttrSpaceReset(str,"Value", temp);
10012}
10013
10014// --- fasttest.TrvSeq..FastEncode
10015void fasttest::TrvSeq_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeq& parent) {
10016 // Value unsigned none mandatory
10017 lib_fast::EncodeUnsigned(buf,parent.Value,false);
10018 (void)state;//only to avoid -Wunused-parameter
10019}
10020
10021// --- fasttest.TrvSeq..FastDecode
10022bool fasttest::TrvSeq_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeq& parent) {
10023 bool ok = true;
10024 // Value unsigned none mandatory
10025 if (ok) {
10026 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
10027 if (!ok) {
10028 state.error << "fasttest.TrvSeq.Value: bad Unsigned" << eol;
10029 }
10030 }
10031 return ok;
10032}
10033
10034// --- fasttest.TrvSeq..FixEncode
10035void fasttest::TrvSeq_FixEncode(cstring& buf, fasttest::TrvSeq& parent, char soh) {
10036 buf << "2=" << parent.Value << soh;
10037}
10038
10039// --- fasttest.SeqTrv.base.CopyOut
10040// Copy fields out of row
10041void fasttest::parent_CopyOut(fasttest::SeqTrv &row, fasttest::TemplateHeader &out) {
10042 // length: field value is computed
10043 // id: field value is computed
10044 (void)row;//only to avoid -Wunused-parameter
10045 (void)out;//only to avoid -Wunused-parameter
10046}
10047
10048// --- fasttest.SeqTrv.TrvSeq.Getary
10049// Access var-length portion as an aryptr. Length is determined from one of the fields.
10050algo::aryptr<fasttest::TrvSeq> fasttest::TrvSeq_Getary(fasttest::SeqTrv& parent) {
10051 return algo::aryptr<fasttest::TrvSeq>(TrvSeq_Addr(parent), TrvSeq_N(parent));
10052}
10053
10054// --- fasttest.SeqTrv.TrvSeq.Addr
10055fasttest::TrvSeq* fasttest::TrvSeq_Addr(fasttest::SeqTrv& parent) {
10056 return (fasttest::TrvSeq*)((u8*)&parent + sizeof(fasttest::SeqTrv)); // address of varlen portion
10057}
10058
10059// --- fasttest.SeqTrv.TrvSeq.ReadStrptrMaybe
10060// Convert string to field. Return success value
10061bool fasttest::TrvSeq_ReadStrptrMaybe(fasttest::SeqTrv& parent, algo::strptr in_str) {
10062 bool retval = true;
10063 if (algo_lib::_db.varlenbuf) {
10064 fasttest::TrvSeq *TrvSeq_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::TrvSeq)).elems) fasttest::TrvSeq;
10065 retval = fasttest::TrvSeq_ReadStrptrMaybe(*TrvSeq_tmp, in_str);
10066 }
10067 (void)parent;//only to avoid -Wunused-parameter
10068 return retval;
10069}
10070
10071// --- fasttest.SeqTrv..ReadFieldMaybe
10072bool fasttest::SeqTrv_ReadFieldMaybe(fasttest::SeqTrv& parent, algo::strptr field, algo::strptr strval) {
10073 bool retval = true;
10074 fasttest::FieldId field_id;
10075 (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
10076 switch(field_id) {
10077 case fasttest_FieldId_base: {
10078 retval = false;
10079 break;
10080 }
10081 case fasttest_FieldId_length: {
10082 retval = false;
10083 break;
10084 }
10085 case fasttest_FieldId_id: {
10086 retval = false;
10087 break;
10088 }
10089 case fasttest_FieldId_TrvSeq: {
10090 retval = TrvSeq_ReadStrptrMaybe(parent, strval);
10091 break;
10092 }
10093 default: break;
10094 }
10095 if (!retval) {
10096 algo_lib::AppendErrtext("attr",field);
10097 }
10098 return retval;
10099}
10100
10101// --- fasttest.SeqTrv..ReadStrptrMaybe
10102// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
10103// Read fields of fasttest::SeqTrv from an ascii string.
10104// The format of the string is an ssim Tuple
10105bool fasttest::SeqTrv_ReadStrptrMaybe(fasttest::SeqTrv &parent, algo::strptr in_str) {
10106 bool retval = true;
10107 retval = algo::StripTypeTag(in_str, "fasttest.SeqTrv");
10108 ind_beg(algo::Attr_curs, attr, in_str) {
10109 retval = retval && SeqTrv_ReadFieldMaybe(parent, attr.name, attr.value);
10110 }ind_end;
10111 return retval;
10112}
10113
10114// --- fasttest.SeqTrv..Print
10115// print string representation of ROW to string STR
10116// cfmt:fasttest.SeqTrv.String printfmt:Tuple
10117void fasttest::SeqTrv_Print(fasttest::SeqTrv& row, algo::cstring& str) {
10118 algo::tempstr temp;
10119 str << "fasttest.SeqTrv";
10120
10121 ind_beg(SeqTrv_TrvSeq_curs,TrvSeq,row) {
10122 fasttest::TrvSeq_Print(TrvSeq, temp);
10123 tempstr name;
10124 name << "TrvSeq.";
10125 name << ind_curs(TrvSeq).index;
10126 PrintAttrSpaceReset(str, name, temp);
10127 }ind_end;
10128}
10129
10130// --- fasttest.SeqTrv..FastEncode
10131void fasttest::SeqTrv_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrv& parent) {
10132 int index = ary_N(buf);
10133 u64 pmap(0);
10134 if (!tid_AssignedQ(state) || parent.id != state.tid) {
10135 lib_fast::EncodeUnsigned(buf,parent.id,false);
10136 lib_fast::SetPmapBit(pmap,0);
10137 }
10138 tid_SetAssigned(state);
10139 state.tid = parent.id;
10140 // TrvSeq sequence none mandatory
10141 {
10142 u32 length = TrvSeq_N(parent);
10143 lib_fast::EncodeUnsigned(buf,length,false);
10144 ind_beg(SeqTrv_TrvSeq_curs,elem,parent) {
10145 TrvSeq_FastEncode(buf,state,elem);
10146 }ind_end;
10147 }
10148 lib_fast::InsertPmap(buf,index,pmap);
10149}
10150
10151// --- fasttest.SeqTrv..FastDecode
10152bool fasttest::SeqTrv_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrv& parent) {
10153 bool ok = true;
10154 // TrvSeq sequence none mandatory
10155 if (ok) {
10156 u32 length(0);
10157 ok = lib_fast::DecodeUnsigned(from,length,false);
10158 if (!ok) {
10159 state.error << "fasttest.SeqTrv.TrvSeq: bad Unsigned" << eol;
10160 }
10161 if (!ok) {
10162 state.error << "fasttest.SeqTrv.TrvSeq: bad length" << eol;
10163 }
10164 for (unsigned i=0; ok && i<length; ++i) {
10165 TrvSeq &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) TrvSeq;
10166 ok = TrvSeq_FastDecode(from,state,seq);
10167 if (!ok) {
10168 state.error << "fasttest.SeqTrv.TrvSeq: element #"<< i+1 << eol;
10169 }
10170 }
10171 }
10172 (void)pmap;//only to avoid -Wunused-parameter
10173 (void)parent;//only to avoid -Wunused-parameter
10174 return ok;
10175}
10176
10177// --- fasttest.SeqTrv..FixEncode
10178void fasttest::SeqTrv_FixEncode(cstring& buf, fasttest::SeqTrv& parent, char soh) {
10179 ind_beg(SeqTrv_TrvSeq_curs,elem,parent) {
10180 TrvSeq_FixEncode(buf,elem,soh);
10181 }ind_end;
10182}
10183
10184// --- fasttest.TrvSeqLenConst..ReadFieldMaybe
10185bool fasttest::TrvSeqLenConst_ReadFieldMaybe(fasttest::TrvSeqLenConst& parent, algo::strptr field, algo::strptr strval) {
10186 bool retval = true;
10187 fasttest::FieldId field_id;
10188 (void)value_SetStrptrMaybe(field_id,field);
10189 switch(field_id) {
10190 case fasttest_FieldId_Value: {
10191 retval = u32_ReadStrptrMaybe(parent.Value, strval);
10192 break;
10193 }
10194 default: break;
10195 }
10196 if (!retval) {
10197 algo_lib::AppendErrtext("attr",field);
10198 }
10199 return retval;
10200}
10201
10202// --- fasttest.TrvSeqLenConst..ReadStrptrMaybe
10203// Read fields of fasttest::TrvSeqLenConst from an ascii string.
10204// The format of the string is an ssim Tuple
10205bool fasttest::TrvSeqLenConst_ReadStrptrMaybe(fasttest::TrvSeqLenConst &parent, algo::strptr in_str) {
10206 bool retval = true;
10207 retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqLenConst");
10208 ind_beg(algo::Attr_curs, attr, in_str) {
10209 retval = retval && TrvSeqLenConst_ReadFieldMaybe(parent, attr.name, attr.value);
10210 }ind_end;
10211 return retval;
10212}
10213
10214// --- fasttest.TrvSeqLenConst..Print
10215// print string representation of ROW to string STR
10216// cfmt:fasttest.TrvSeqLenConst.String printfmt:Tuple
10217void fasttest::TrvSeqLenConst_Print(fasttest::TrvSeqLenConst& row, algo::cstring& str) {
10218 algo::tempstr temp;
10219 str << "fasttest.TrvSeqLenConst";
10220
10221 u32_Print(row.Value, temp);
10222 PrintAttrSpaceReset(str,"Value", temp);
10223}
10224
10225// --- fasttest.TrvSeqLenConst..FastEncode
10226void fasttest::TrvSeqLenConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqLenConst& parent) {
10227 // Value unsigned none mandatory
10228 lib_fast::EncodeUnsigned(buf,parent.Value,false);
10229 (void)state;//only to avoid -Wunused-parameter
10230}
10231
10232// --- fasttest.TrvSeqLenConst..FastDecode
10233bool fasttest::TrvSeqLenConst_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqLenConst& parent) {
10234 bool ok = true;
10235 // Value unsigned none mandatory
10236 if (ok) {
10237 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
10238 if (!ok) {
10239 state.error << "fasttest.TrvSeqLenConst.Value: bad Unsigned" << eol;
10240 }
10241 }
10242 return ok;
10243}
10244
10245// --- fasttest.TrvSeqLenConst..FixEncode
10246void fasttest::TrvSeqLenConst_FixEncode(cstring& buf, fasttest::TrvSeqLenConst& parent, char soh) {
10247 buf << "3=" << parent.Value << soh;
10248}
10249
10250// --- fasttest.SeqTrvLenConst.base.CopyOut
10251// Copy fields out of row
10252void fasttest::parent_CopyOut(fasttest::SeqTrvLenConst &row, fasttest::TemplateHeader &out) {
10253 // length: field value is computed
10254 // id: field value is computed
10255 (void)row;//only to avoid -Wunused-parameter
10256 (void)out;//only to avoid -Wunused-parameter
10257}
10258
10259// --- fasttest.SeqTrvLenConst..ReadFieldMaybe
10260bool fasttest::SeqTrvLenConst_ReadFieldMaybe(fasttest::SeqTrvLenConst& parent, algo::strptr field, algo::strptr strval) {
10261 bool retval = true;
10262 fasttest::FieldId field_id;
10263 (void)value_SetStrptrMaybe(field_id,field);
10264 switch(field_id) {
10265 case fasttest_FieldId_base: {
10266 retval = false;
10267 break;
10268 }
10269 case fasttest_FieldId_length: {
10270 retval = false;
10271 break;
10272 }
10273 case fasttest_FieldId_id: {
10274 retval = false;
10275 break;
10276 }
10277 case fasttest_FieldId_TrvSeqLenConst: {
10278 retval = fasttest::TrvSeqLenConst_ReadStrptrMaybe(parent.TrvSeqLenConst, strval);
10279 break;
10280 }
10281 default: break;
10282 }
10283 if (!retval) {
10284 algo_lib::AppendErrtext("attr",field);
10285 }
10286 return retval;
10287}
10288
10289// --- fasttest.SeqTrvLenConst..ReadStrptrMaybe
10290// Read fields of fasttest::SeqTrvLenConst from an ascii string.
10291// The format of the string is an ssim Tuple
10292bool fasttest::SeqTrvLenConst_ReadStrptrMaybe(fasttest::SeqTrvLenConst &parent, algo::strptr in_str) {
10293 bool retval = true;
10294 retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenConst");
10295 ind_beg(algo::Attr_curs, attr, in_str) {
10296 retval = retval && SeqTrvLenConst_ReadFieldMaybe(parent, attr.name, attr.value);
10297 }ind_end;
10298 return retval;
10299}
10300
10301// --- fasttest.SeqTrvLenConst..Print
10302// print string representation of ROW to string STR
10303// cfmt:fasttest.SeqTrvLenConst.String printfmt:Tuple
10304void fasttest::SeqTrvLenConst_Print(fasttest::SeqTrvLenConst& row, algo::cstring& str) {
10305 algo::tempstr temp;
10306 str << "fasttest.SeqTrvLenConst";
10307
10308 fasttest::TrvSeqLenConst_Print(row.TrvSeqLenConst, temp);
10309 PrintAttrSpaceReset(str,"TrvSeqLenConst", temp);
10310}
10311
10312// --- fasttest.SeqTrvLenConst..FastEncode
10313void fasttest::SeqTrvLenConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenConst& parent) {
10314 int index = ary_N(buf);
10315 u64 pmap(0);
10316 if (!tid_AssignedQ(state) || parent.id != state.tid) {
10317 lib_fast::EncodeUnsigned(buf,parent.id,false);
10318 lib_fast::SetPmapBit(pmap,0);
10319 }
10320 tid_SetAssigned(state);
10321 state.tid = parent.id;
10322 // TrvSeqLenConst sequence none mandatory
10323 TrvSeqLenConst_FastEncode(buf,state,parent.TrvSeqLenConst);
10324 lib_fast::InsertPmap(buf,index,pmap);
10325}
10326
10327// --- fasttest.SeqTrvLenConst..FastDecode
10328bool fasttest::SeqTrvLenConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenConst& parent) {
10329 bool ok = true;
10330 // TrvSeqLenConst sequence none mandatory
10331 if (ok) {
10332 ok = TrvSeqLenConst_FastDecode(from,state,parent.TrvSeqLenConst);
10333 }
10334 (void)pmap;//only to avoid -Wunused-parameter
10335 return ok;
10336}
10337
10338// --- fasttest.SeqTrvLenConst..FixEncode
10339void fasttest::SeqTrvLenConst_FixEncode(cstring& buf, fasttest::SeqTrvLenConst& parent, char soh) {
10340 buf << "2=1" << soh;
10341 buf << "1=" << parent.TrvSeqLenConst << soh;
10342}
10343
10344// --- fasttest.TrvSeqLenConstOpt..ReadFieldMaybe
10345bool fasttest::TrvSeqLenConstOpt_ReadFieldMaybe(fasttest::TrvSeqLenConstOpt& parent, algo::strptr field, algo::strptr strval) {
10346 bool retval = true;
10347 fasttest::FieldId field_id;
10348 (void)value_SetStrptrMaybe(field_id,field);
10349 switch(field_id) {
10350 case fasttest_FieldId_Value: {
10351 retval = u32_ReadStrptrMaybe(parent.Value, strval);
10352 break;
10353 }
10354 default: break;
10355 }
10356 if (!retval) {
10357 algo_lib::AppendErrtext("attr",field);
10358 }
10359 return retval;
10360}
10361
10362// --- fasttest.TrvSeqLenConstOpt..ReadStrptrMaybe
10363// Read fields of fasttest::TrvSeqLenConstOpt from an ascii string.
10364// The format of the string is an ssim Tuple
10365bool fasttest::TrvSeqLenConstOpt_ReadStrptrMaybe(fasttest::TrvSeqLenConstOpt &parent, algo::strptr in_str) {
10366 bool retval = true;
10367 retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqLenConstOpt");
10368 ind_beg(algo::Attr_curs, attr, in_str) {
10369 retval = retval && TrvSeqLenConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
10370 }ind_end;
10371 return retval;
10372}
10373
10374// --- fasttest.TrvSeqLenConstOpt..Print
10375// print string representation of ROW to string STR
10376// cfmt:fasttest.TrvSeqLenConstOpt.String printfmt:Tuple
10377void fasttest::TrvSeqLenConstOpt_Print(fasttest::TrvSeqLenConstOpt& row, algo::cstring& str) {
10378 algo::tempstr temp;
10379 str << "fasttest.TrvSeqLenConstOpt";
10380
10381 u32_Print(row.Value, temp);
10382 PrintAttrSpaceReset(str,"Value", temp);
10383}
10384
10385// --- fasttest.TrvSeqLenConstOpt..FastEncode
10386void fasttest::TrvSeqLenConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqLenConstOpt& parent) {
10387 // Value unsigned none mandatory
10388 lib_fast::EncodeUnsigned(buf,parent.Value,false);
10389 (void)state;//only to avoid -Wunused-parameter
10390}
10391
10392// --- fasttest.TrvSeqLenConstOpt..FastDecode
10393bool fasttest::TrvSeqLenConstOpt_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqLenConstOpt& parent) {
10394 bool ok = true;
10395 // Value unsigned none mandatory
10396 if (ok) {
10397 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
10398 if (!ok) {
10399 state.error << "fasttest.TrvSeqLenConstOpt.Value: bad Unsigned" << eol;
10400 }
10401 }
10402 return ok;
10403}
10404
10405// --- fasttest.TrvSeqLenConstOpt..FixEncode
10406void fasttest::TrvSeqLenConstOpt_FixEncode(cstring& buf, fasttest::TrvSeqLenConstOpt& parent, char soh) {
10407 buf << "3=" << parent.Value << soh;
10408}
10409
10410// --- fasttest.SeqTrvLenConstOpt.base.CopyOut
10411// Copy fields out of row
10412void fasttest::parent_CopyOut(fasttest::SeqTrvLenConstOpt &row, fasttest::TemplateHeader &out) {
10413 // length: field value is computed
10414 // id: field value is computed
10415 (void)row;//only to avoid -Wunused-parameter
10416 (void)out;//only to avoid -Wunused-parameter
10417}
10418
10419// --- fasttest.SeqTrvLenConstOpt.TrvSeqLenConstOpt.ReadStrptrMaybe
10420inline static bool fasttest::TrvSeqLenConstOpt_ReadStrptrMaybe(fasttest::SeqTrvLenConstOpt &parent, algo::strptr in_str) {
10421 bool retval = true;
10422 fasttest::TrvSeqLenConstOpt TrvSeqLenConstOpt_tmp;
10423 retval = fasttest::TrvSeqLenConstOpt_ReadStrptrMaybe(TrvSeqLenConstOpt_tmp, in_str);
10424 if (retval) {
10425 TrvSeqLenConstOpt_Set(parent, TrvSeqLenConstOpt_tmp);
10426 }
10427 return retval;
10428}
10429
10430// --- fasttest.SeqTrvLenConstOpt.pmask_bitcurs.Next
10431// proceed to next item
10432void fasttest::SeqTrvLenConstOpt_pmask_bitcurs_Next(SeqTrvLenConstOpt_pmask_bitcurs &curs) {
10433 ++curs.bit;
10434 int index = curs.bit / 32;
10435 int offset = curs.bit % 32;
10436 for (; index < curs.n_elems; ++index, offset = 0) {
10437 u64 rest = curs.elems[index] >> offset;
10438 if (rest) {
10439 offset += algo::u64_BitScanForward(rest);
10440 break;
10441 }
10442 }
10443 curs.bit = index * 32 + offset;
10444}
10445
10446// --- fasttest.SeqTrvLenConstOpt..ReadFieldMaybe
10447bool fasttest::SeqTrvLenConstOpt_ReadFieldMaybe(fasttest::SeqTrvLenConstOpt& parent, algo::strptr field, algo::strptr strval) {
10448 bool retval = true;
10449 fasttest::FieldId field_id;
10450 (void)value_SetStrptrMaybe(field_id,field);
10451 switch(field_id) {
10452 case fasttest_FieldId_base: {
10453 retval = false;
10454 break;
10455 }
10456 case fasttest_FieldId_length: {
10457 retval = false;
10458 break;
10459 }
10460 case fasttest_FieldId_id: {
10461 retval = false;
10462 break;
10463 }
10464 case fasttest_FieldId_pmask: {
10465 retval = false;
10466 break;
10467 }
10468 case fasttest_FieldId_TrvSeqLenConstOpt: {
10469 retval = TrvSeqLenConstOpt_ReadStrptrMaybe(parent, strval);
10470 if (retval) {
10471 pmask_qSetBit(parent, 0);
10472 }
10473 break;
10474 }
10475 default: break;
10476 }
10477 if (!retval) {
10478 algo_lib::AppendErrtext("attr",field);
10479 }
10480 return retval;
10481}
10482
10483// --- fasttest.SeqTrvLenConstOpt..ReadStrptrMaybe
10484// Read fields of fasttest::SeqTrvLenConstOpt from an ascii string.
10485// The format of the string is an ssim Tuple
10486bool fasttest::SeqTrvLenConstOpt_ReadStrptrMaybe(fasttest::SeqTrvLenConstOpt &parent, algo::strptr in_str) {
10487 bool retval = true;
10488 retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenConstOpt");
10489 ind_beg(algo::Attr_curs, attr, in_str) {
10490 retval = retval && SeqTrvLenConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
10491 }ind_end;
10492 return retval;
10493}
10494
10495// --- fasttest.SeqTrvLenConstOpt..Print
10496// print string representation of ROW to string STR
10497// cfmt:fasttest.SeqTrvLenConstOpt.String printfmt:Tuple
10498void fasttest::SeqTrvLenConstOpt_Print(fasttest::SeqTrvLenConstOpt& row, algo::cstring& str) {
10499 algo::tempstr temp;
10500 str << "fasttest.SeqTrvLenConstOpt";
10501
10502 if (TrvSeqLenConstOpt_PresentQ(row)) {
10503 fasttest::TrvSeqLenConstOpt_Print(row.TrvSeqLenConstOpt, temp);
10504 PrintAttrSpaceReset(str,"TrvSeqLenConstOpt", temp);
10505 }
10506}
10507
10508// --- fasttest.SeqTrvLenConstOpt..FastEncode
10509void fasttest::SeqTrvLenConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenConstOpt& parent) {
10510 int index = ary_N(buf);
10511 u64 pmap(0);
10512 if (!tid_AssignedQ(state) || parent.id != state.tid) {
10513 lib_fast::EncodeUnsigned(buf,parent.id,false);
10514 lib_fast::SetPmapBit(pmap,0);
10515 }
10516 tid_SetAssigned(state);
10517 state.tid = parent.id;
10518 // TrvSeqLenConstOpt sequence none optional
10519 if (TrvSeqLenConstOpt_PresentQ(parent)) {
10520 TrvSeqLenConstOpt_FastEncode(buf,state,parent.TrvSeqLenConstOpt);
10521 lib_fast::SetPmapBit(pmap,1);
10522 }
10523 lib_fast::InsertPmap(buf,index,pmap);
10524}
10525
10526// --- fasttest.SeqTrvLenConstOpt..FastDecode
10527bool fasttest::SeqTrvLenConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenConstOpt& parent) {
10528 bool ok = true;
10529 // TrvSeqLenConstOpt sequence none optional
10530 if (ok) {
10531 bool prs = lib_fast::GetPmapBit(pmap,1);
10532 pmask_qSetBitVal(parent,TrvSeqLenConstOpt_Present_GetBit(parent),prs);
10533 if (prs) {
10534 ok = TrvSeqLenConstOpt_FastDecode(from,state,parent.TrvSeqLenConstOpt);
10535 }
10536 }
10537 return ok;
10538}
10539
10540// --- fasttest.SeqTrvLenConstOpt..FixEncode
10541void fasttest::SeqTrvLenConstOpt_FixEncode(cstring& buf, fasttest::SeqTrvLenConstOpt& parent, char soh) {
10542 buf << "2=1" << soh;
10543 if (TrvSeqLenConstOpt_PresentQ(parent)) {
10544 buf << "1=" << parent.TrvSeqLenConstOpt << soh;
10545 }
10546}
10547
10548// --- fasttest.TrvSeqLenDflt..ReadFieldMaybe
10549bool fasttest::TrvSeqLenDflt_ReadFieldMaybe(fasttest::TrvSeqLenDflt& parent, algo::strptr field, algo::strptr strval) {
10550 bool retval = true;
10551 fasttest::FieldId field_id;
10552 (void)value_SetStrptrMaybe(field_id,field);
10553 switch(field_id) {
10554 case fasttest_FieldId_Value: {
10555 retval = u32_ReadStrptrMaybe(parent.Value, strval);
10556 break;
10557 }
10558 default: break;
10559 }
10560 if (!retval) {
10561 algo_lib::AppendErrtext("attr",field);
10562 }
10563 return retval;
10564}
10565
10566// --- fasttest.TrvSeqLenDflt..ReadStrptrMaybe
10567// Read fields of fasttest::TrvSeqLenDflt from an ascii string.
10568// The format of the string is an ssim Tuple
10569bool fasttest::TrvSeqLenDflt_ReadStrptrMaybe(fasttest::TrvSeqLenDflt &parent, algo::strptr in_str) {
10570 bool retval = true;
10571 retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqLenDflt");
10572 ind_beg(algo::Attr_curs, attr, in_str) {
10573 retval = retval && TrvSeqLenDflt_ReadFieldMaybe(parent, attr.name, attr.value);
10574 }ind_end;
10575 return retval;
10576}
10577
10578// --- fasttest.TrvSeqLenDflt..Print
10579// print string representation of ROW to string STR
10580// cfmt:fasttest.TrvSeqLenDflt.String printfmt:Tuple
10581void fasttest::TrvSeqLenDflt_Print(fasttest::TrvSeqLenDflt& row, algo::cstring& str) {
10582 algo::tempstr temp;
10583 str << "fasttest.TrvSeqLenDflt";
10584
10585 u32_Print(row.Value, temp);
10586 PrintAttrSpaceReset(str,"Value", temp);
10587}
10588
10589// --- fasttest.TrvSeqLenDflt..FastEncode
10590void fasttest::TrvSeqLenDflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqLenDflt& parent) {
10591 // Value unsigned none mandatory
10592 lib_fast::EncodeUnsigned(buf,parent.Value,false);
10593 (void)state;//only to avoid -Wunused-parameter
10594}
10595
10596// --- fasttest.TrvSeqLenDflt..FastDecode
10597bool fasttest::TrvSeqLenDflt_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqLenDflt& parent) {
10598 bool ok = true;
10599 // Value unsigned none mandatory
10600 if (ok) {
10601 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
10602 if (!ok) {
10603 state.error << "fasttest.TrvSeqLenDflt.Value: bad Unsigned" << eol;
10604 }
10605 }
10606 return ok;
10607}
10608
10609// --- fasttest.TrvSeqLenDflt..FixEncode
10610void fasttest::TrvSeqLenDflt_FixEncode(cstring& buf, fasttest::TrvSeqLenDflt& parent, char soh) {
10611 buf << "3=" << parent.Value << soh;
10612}
10613
10614// --- fasttest.SeqTrvLenDflt.base.CopyOut
10615// Copy fields out of row
10616void fasttest::parent_CopyOut(fasttest::SeqTrvLenDflt &row, fasttest::TemplateHeader &out) {
10617 // length: field value is computed
10618 // id: field value is computed
10619 (void)row;//only to avoid -Wunused-parameter
10620 (void)out;//only to avoid -Wunused-parameter
10621}
10622
10623// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt.Getary
10624// Access var-length portion as an aryptr. Length is determined from one of the fields.
10625algo::aryptr<fasttest::TrvSeqLenDflt> fasttest::TrvSeqLenDflt_Getary(fasttest::SeqTrvLenDflt& parent) {
10626 return algo::aryptr<fasttest::TrvSeqLenDflt>(TrvSeqLenDflt_Addr(parent), TrvSeqLenDflt_N(parent));
10627}
10628
10629// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt.Addr
10630fasttest::TrvSeqLenDflt* fasttest::TrvSeqLenDflt_Addr(fasttest::SeqTrvLenDflt& parent) {
10631 return (fasttest::TrvSeqLenDflt*)((u8*)&parent + sizeof(fasttest::SeqTrvLenDflt)); // address of varlen portion
10632}
10633
10634// --- fasttest.SeqTrvLenDflt.TrvSeqLenDflt.ReadStrptrMaybe
10635// Convert string to field. Return success value
10636bool fasttest::TrvSeqLenDflt_ReadStrptrMaybe(fasttest::SeqTrvLenDflt& parent, algo::strptr in_str) {
10637 bool retval = true;
10638 if (algo_lib::_db.varlenbuf) {
10639 fasttest::TrvSeqLenDflt *TrvSeqLenDflt_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::TrvSeqLenDflt)).elems) fasttest::TrvSeqLenDflt;
10640 retval = fasttest::TrvSeqLenDflt_ReadStrptrMaybe(*TrvSeqLenDflt_tmp, in_str);
10641 }
10642 (void)parent;//only to avoid -Wunused-parameter
10643 return retval;
10644}
10645
10646// --- fasttest.SeqTrvLenDflt..ReadFieldMaybe
10647bool fasttest::SeqTrvLenDflt_ReadFieldMaybe(fasttest::SeqTrvLenDflt& parent, algo::strptr field, algo::strptr strval) {
10648 bool retval = true;
10649 fasttest::FieldId field_id;
10650 (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
10651 switch(field_id) {
10652 case fasttest_FieldId_base: {
10653 retval = false;
10654 break;
10655 }
10656 case fasttest_FieldId_length: {
10657 retval = false;
10658 break;
10659 }
10660 case fasttest_FieldId_id: {
10661 retval = false;
10662 break;
10663 }
10664 case fasttest_FieldId_TrvSeqLenDflt: {
10665 retval = TrvSeqLenDflt_ReadStrptrMaybe(parent, strval);
10666 break;
10667 }
10668 default: break;
10669 }
10670 if (!retval) {
10671 algo_lib::AppendErrtext("attr",field);
10672 }
10673 return retval;
10674}
10675
10676// --- fasttest.SeqTrvLenDflt..ReadStrptrMaybe
10677// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
10678// Read fields of fasttest::SeqTrvLenDflt from an ascii string.
10679// The format of the string is an ssim Tuple
10680bool fasttest::SeqTrvLenDflt_ReadStrptrMaybe(fasttest::SeqTrvLenDflt &parent, algo::strptr in_str) {
10681 bool retval = true;
10682 retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenDflt");
10683 ind_beg(algo::Attr_curs, attr, in_str) {
10684 retval = retval && SeqTrvLenDflt_ReadFieldMaybe(parent, attr.name, attr.value);
10685 }ind_end;
10686 return retval;
10687}
10688
10689// --- fasttest.SeqTrvLenDflt..Print
10690// print string representation of ROW to string STR
10691// cfmt:fasttest.SeqTrvLenDflt.String printfmt:Tuple
10692void fasttest::SeqTrvLenDflt_Print(fasttest::SeqTrvLenDflt& row, algo::cstring& str) {
10693 algo::tempstr temp;
10694 str << "fasttest.SeqTrvLenDflt";
10695
10696 ind_beg(SeqTrvLenDflt_TrvSeqLenDflt_curs,TrvSeqLenDflt,row) {
10697 fasttest::TrvSeqLenDflt_Print(TrvSeqLenDflt, temp);
10698 tempstr name;
10699 name << "TrvSeqLenDflt.";
10700 name << ind_curs(TrvSeqLenDflt).index;
10701 PrintAttrSpaceReset(str, name, temp);
10702 }ind_end;
10703}
10704
10705// --- fasttest.SeqTrvLenDflt..FastEncode
10706void fasttest::SeqTrvLenDflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenDflt& parent) {
10707 int index = ary_N(buf);
10708 u64 pmap(0);
10709 if (!tid_AssignedQ(state) || parent.id != state.tid) {
10710 lib_fast::EncodeUnsigned(buf,parent.id,false);
10711 lib_fast::SetPmapBit(pmap,0);
10712 }
10713 tid_SetAssigned(state);
10714 state.tid = parent.id;
10715 // TrvSeqLenDflt sequence none mandatory
10716 {
10717 u32 length = TrvSeqLenDflt_N(parent);
10718 if (length != 1) {
10719 lib_fast::EncodeUnsigned(buf,length,false);
10720 lib_fast::SetPmapBit(pmap,1);
10721 }
10722 ind_beg(SeqTrvLenDflt_TrvSeqLenDflt_curs,elem,parent) {
10723 TrvSeqLenDflt_FastEncode(buf,state,elem);
10724 }ind_end;
10725 }
10726 lib_fast::InsertPmap(buf,index,pmap);
10727}
10728
10729// --- fasttest.SeqTrvLenDflt..FastDecode
10730bool fasttest::SeqTrvLenDflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenDflt& parent) {
10731 bool ok = true;
10732 // TrvSeqLenDflt sequence none mandatory
10733 if (ok) {
10734 u32 length(0);
10735 bool prs = lib_fast::GetPmapBit(pmap,1);
10736 if (prs) {
10737 ok = lib_fast::DecodeUnsigned(from,length,false);
10738 if (!ok) {
10739 state.error << "fasttest.SeqTrvLenDflt.TrvSeqLenDflt: bad Unsigned" << eol;
10740 }
10741 } else {
10742 length = 1;
10743 }
10744 if (!ok) {
10745 state.error << "fasttest.SeqTrvLenDflt.TrvSeqLenDflt: bad length" << eol;
10746 }
10747 for (unsigned i=0; ok && i<length; ++i) {
10748 TrvSeqLenDflt &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) TrvSeqLenDflt;
10749 ok = TrvSeqLenDflt_FastDecode(from,state,seq);
10750 if (!ok) {
10751 state.error << "fasttest.SeqTrvLenDflt.TrvSeqLenDflt: element #"<< i+1 << eol;
10752 }
10753 }
10754 }
10755 (void)parent;//only to avoid -Wunused-parameter
10756 return ok;
10757}
10758
10759// --- fasttest.SeqTrvLenDflt..FixEncode
10760void fasttest::SeqTrvLenDflt_FixEncode(cstring& buf, fasttest::SeqTrvLenDflt& parent, char soh) {
10761 {
10762 u32 length = TrvSeqLenDflt_N(parent);
10763 if (length) {
10764 buf << "2=" << length << soh;
10765 }
10766 }
10767 ind_beg(SeqTrvLenDflt_TrvSeqLenDflt_curs,elem,parent) {
10768 TrvSeqLenDflt_FixEncode(buf,elem,soh);
10769 }ind_end;
10770}
10771
10772// --- fasttest.TrvSeqDfltOpt..ReadFieldMaybe
10773bool fasttest::TrvSeqDfltOpt_ReadFieldMaybe(fasttest::TrvSeqDfltOpt& parent, algo::strptr field, algo::strptr strval) {
10774 bool retval = true;
10775 fasttest::FieldId field_id;
10776 (void)value_SetStrptrMaybe(field_id,field);
10777 switch(field_id) {
10778 case fasttest_FieldId_Value: {
10779 retval = u32_ReadStrptrMaybe(parent.Value, strval);
10780 break;
10781 }
10782 default: break;
10783 }
10784 if (!retval) {
10785 algo_lib::AppendErrtext("attr",field);
10786 }
10787 return retval;
10788}
10789
10790// --- fasttest.TrvSeqDfltOpt..ReadStrptrMaybe
10791// Read fields of fasttest::TrvSeqDfltOpt from an ascii string.
10792// The format of the string is an ssim Tuple
10793bool fasttest::TrvSeqDfltOpt_ReadStrptrMaybe(fasttest::TrvSeqDfltOpt &parent, algo::strptr in_str) {
10794 bool retval = true;
10795 retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqDfltOpt");
10796 ind_beg(algo::Attr_curs, attr, in_str) {
10797 retval = retval && TrvSeqDfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
10798 }ind_end;
10799 return retval;
10800}
10801
10802// --- fasttest.TrvSeqDfltOpt..Print
10803// print string representation of ROW to string STR
10804// cfmt:fasttest.TrvSeqDfltOpt.String printfmt:Tuple
10805void fasttest::TrvSeqDfltOpt_Print(fasttest::TrvSeqDfltOpt& row, algo::cstring& str) {
10806 algo::tempstr temp;
10807 str << "fasttest.TrvSeqDfltOpt";
10808
10809 u32_Print(row.Value, temp);
10810 PrintAttrSpaceReset(str,"Value", temp);
10811}
10812
10813// --- fasttest.TrvSeqDfltOpt..FastEncode
10814void fasttest::TrvSeqDfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqDfltOpt& parent) {
10815 // Value unsigned none mandatory
10816 lib_fast::EncodeUnsigned(buf,parent.Value,false);
10817 (void)state;//only to avoid -Wunused-parameter
10818}
10819
10820// --- fasttest.TrvSeqDfltOpt..FastDecode
10821bool fasttest::TrvSeqDfltOpt_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqDfltOpt& parent) {
10822 bool ok = true;
10823 // Value unsigned none mandatory
10824 if (ok) {
10825 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
10826 if (!ok) {
10827 state.error << "fasttest.TrvSeqDfltOpt.Value: bad Unsigned" << eol;
10828 }
10829 }
10830 return ok;
10831}
10832
10833// --- fasttest.TrvSeqDfltOpt..FixEncode
10834void fasttest::TrvSeqDfltOpt_FixEncode(cstring& buf, fasttest::TrvSeqDfltOpt& parent, char soh) {
10835 buf << "3=" << parent.Value << soh;
10836}
10837
10838// --- fasttest.SeqTrvLenDfltOpt.base.CopyOut
10839// Copy fields out of row
10840void fasttest::parent_CopyOut(fasttest::SeqTrvLenDfltOpt &row, fasttest::TemplateHeader &out) {
10841 // length: field value is computed
10842 // id: field value is computed
10843 (void)row;//only to avoid -Wunused-parameter
10844 (void)out;//only to avoid -Wunused-parameter
10845}
10846
10847// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt.Getary
10848// Access var-length portion as an aryptr. Length is determined from one of the fields.
10849algo::aryptr<fasttest::TrvSeqDfltOpt> fasttest::TrvSeqDfltOpt_Getary(fasttest::SeqTrvLenDfltOpt& parent) {
10850 return algo::aryptr<fasttest::TrvSeqDfltOpt>(TrvSeqDfltOpt_Addr(parent), TrvSeqDfltOpt_N(parent));
10851}
10852
10853// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt.Addr
10854fasttest::TrvSeqDfltOpt* fasttest::TrvSeqDfltOpt_Addr(fasttest::SeqTrvLenDfltOpt& parent) {
10855 return (fasttest::TrvSeqDfltOpt*)((u8*)&parent + sizeof(fasttest::SeqTrvLenDfltOpt)); // address of varlen portion
10856}
10857
10858// --- fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt.ReadStrptrMaybe
10859// Convert string to field. Return success value
10860bool fasttest::TrvSeqDfltOpt_ReadStrptrMaybe(fasttest::SeqTrvLenDfltOpt& parent, algo::strptr in_str) {
10861 bool retval = true;
10862 if (algo_lib::_db.varlenbuf) {
10863 fasttest::TrvSeqDfltOpt *TrvSeqDfltOpt_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::TrvSeqDfltOpt)).elems) fasttest::TrvSeqDfltOpt;
10864 retval = fasttest::TrvSeqDfltOpt_ReadStrptrMaybe(*TrvSeqDfltOpt_tmp, in_str);
10865 }
10866 (void)parent;//only to avoid -Wunused-parameter
10867 return retval;
10868}
10869
10870// --- fasttest.SeqTrvLenDfltOpt..ReadFieldMaybe
10871bool fasttest::SeqTrvLenDfltOpt_ReadFieldMaybe(fasttest::SeqTrvLenDfltOpt& parent, algo::strptr field, algo::strptr strval) {
10872 bool retval = true;
10873 fasttest::FieldId field_id;
10874 (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
10875 switch(field_id) {
10876 case fasttest_FieldId_base: {
10877 retval = false;
10878 break;
10879 }
10880 case fasttest_FieldId_length: {
10881 retval = false;
10882 break;
10883 }
10884 case fasttest_FieldId_id: {
10885 retval = false;
10886 break;
10887 }
10888 case fasttest_FieldId_TrvSeqDfltOpt: {
10889 retval = TrvSeqDfltOpt_ReadStrptrMaybe(parent, strval);
10890 break;
10891 }
10892 default: break;
10893 }
10894 if (!retval) {
10895 algo_lib::AppendErrtext("attr",field);
10896 }
10897 return retval;
10898}
10899
10900// --- fasttest.SeqTrvLenDfltOpt..ReadStrptrMaybe
10901// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
10902// Read fields of fasttest::SeqTrvLenDfltOpt from an ascii string.
10903// The format of the string is an ssim Tuple
10904bool fasttest::SeqTrvLenDfltOpt_ReadStrptrMaybe(fasttest::SeqTrvLenDfltOpt &parent, algo::strptr in_str) {
10905 bool retval = true;
10906 retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenDfltOpt");
10907 ind_beg(algo::Attr_curs, attr, in_str) {
10908 retval = retval && SeqTrvLenDfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
10909 }ind_end;
10910 return retval;
10911}
10912
10913// --- fasttest.SeqTrvLenDfltOpt..Print
10914// print string representation of ROW to string STR
10915// cfmt:fasttest.SeqTrvLenDfltOpt.String printfmt:Tuple
10916void fasttest::SeqTrvLenDfltOpt_Print(fasttest::SeqTrvLenDfltOpt& row, algo::cstring& str) {
10917 algo::tempstr temp;
10918 str << "fasttest.SeqTrvLenDfltOpt";
10919
10920 ind_beg(SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs,TrvSeqDfltOpt,row) {
10921 fasttest::TrvSeqDfltOpt_Print(TrvSeqDfltOpt, temp);
10922 tempstr name;
10923 name << "TrvSeqDfltOpt.";
10924 name << ind_curs(TrvSeqDfltOpt).index;
10925 PrintAttrSpaceReset(str, name, temp);
10926 }ind_end;
10927}
10928
10929// --- fasttest.SeqTrvLenDfltOpt..FastEncode
10930void fasttest::SeqTrvLenDfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenDfltOpt& parent) {
10931 int index = ary_N(buf);
10932 u64 pmap(0);
10933 if (!tid_AssignedQ(state) || parent.id != state.tid) {
10934 lib_fast::EncodeUnsigned(buf,parent.id,false);
10935 lib_fast::SetPmapBit(pmap,0);
10936 }
10937 tid_SetAssigned(state);
10938 state.tid = parent.id;
10939 // TrvSeqDfltOpt sequence none optional
10940 {
10941 u32 length = TrvSeqDfltOpt_N(parent);
10942 if (length) {
10943 if (length != 1) {
10944 lib_fast::EncodeUnsigned(buf,length,true);
10945 lib_fast::SetPmapBit(pmap,1);
10946 }
10947 } else {
10948 lib_fast::EncodeNull(buf);
10949 lib_fast::SetPmapBit(pmap,1);
10950 }
10951 ind_beg(SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs,elem,parent) {
10952 TrvSeqDfltOpt_FastEncode(buf,state,elem);
10953 }ind_end;
10954 }
10955 lib_fast::InsertPmap(buf,index,pmap);
10956}
10957
10958// --- fasttest.SeqTrvLenDfltOpt..FastDecode
10959bool fasttest::SeqTrvLenDfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenDfltOpt& parent) {
10960 bool ok = true;
10961 // TrvSeqDfltOpt sequence none optional
10962 if (ok) {
10963 u32 length(0);
10964 bool prs = lib_fast::GetPmapBit(pmap,1);
10965 if (prs) {
10966 prs = !lib_fast::DecodeNull(from);
10967 if (prs) {
10968 ok = lib_fast::DecodeUnsigned(from,length,true);
10969 if (!ok) {
10970 state.error << "fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt: bad Unsigned" << eol;
10971 }
10972 }
10973 } else {
10974 length = 1;
10975 prs = true;
10976 }
10977 ;
10978 if (!ok) {
10979 state.error << "fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt: bad length" << eol;
10980 }
10981 length = prs ? length : 0;
10982 for (unsigned i=0; ok && i<length; ++i) {
10983 TrvSeqDfltOpt &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) TrvSeqDfltOpt;
10984 ok = TrvSeqDfltOpt_FastDecode(from,state,seq);
10985 if (!ok) {
10986 state.error << "fasttest.SeqTrvLenDfltOpt.TrvSeqDfltOpt: element #"<< i+1 << eol;
10987 }
10988 }
10989 }
10990 (void)parent;//only to avoid -Wunused-parameter
10991 return ok;
10992}
10993
10994// --- fasttest.SeqTrvLenDfltOpt..FixEncode
10995void fasttest::SeqTrvLenDfltOpt_FixEncode(cstring& buf, fasttest::SeqTrvLenDfltOpt& parent, char soh) {
10996 {
10997 u32 length = TrvSeqDfltOpt_N(parent);
10998 if (length) {
10999 buf << "2=" << length << soh;
11000 }
11001 }
11002 ind_beg(SeqTrvLenDfltOpt_TrvSeqDfltOpt_curs,elem,parent) {
11003 TrvSeqDfltOpt_FixEncode(buf,elem,soh);
11004 }ind_end;
11005}
11006
11007// --- fasttest.TrvSeqLenNone..ReadFieldMaybe
11008bool fasttest::TrvSeqLenNone_ReadFieldMaybe(fasttest::TrvSeqLenNone& parent, algo::strptr field, algo::strptr strval) {
11009 bool retval = true;
11010 fasttest::FieldId field_id;
11011 (void)value_SetStrptrMaybe(field_id,field);
11012 switch(field_id) {
11013 case fasttest_FieldId_Value: {
11014 retval = u32_ReadStrptrMaybe(parent.Value, strval);
11015 break;
11016 }
11017 default: break;
11018 }
11019 if (!retval) {
11020 algo_lib::AppendErrtext("attr",field);
11021 }
11022 return retval;
11023}
11024
11025// --- fasttest.TrvSeqLenNone..ReadStrptrMaybe
11026// Read fields of fasttest::TrvSeqLenNone from an ascii string.
11027// The format of the string is an ssim Tuple
11028bool fasttest::TrvSeqLenNone_ReadStrptrMaybe(fasttest::TrvSeqLenNone &parent, algo::strptr in_str) {
11029 bool retval = true;
11030 retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqLenNone");
11031 ind_beg(algo::Attr_curs, attr, in_str) {
11032 retval = retval && TrvSeqLenNone_ReadFieldMaybe(parent, attr.name, attr.value);
11033 }ind_end;
11034 return retval;
11035}
11036
11037// --- fasttest.TrvSeqLenNone..Print
11038// print string representation of ROW to string STR
11039// cfmt:fasttest.TrvSeqLenNone.String printfmt:Tuple
11040void fasttest::TrvSeqLenNone_Print(fasttest::TrvSeqLenNone& row, algo::cstring& str) {
11041 algo::tempstr temp;
11042 str << "fasttest.TrvSeqLenNone";
11043
11044 u32_Print(row.Value, temp);
11045 PrintAttrSpaceReset(str,"Value", temp);
11046}
11047
11048// --- fasttest.TrvSeqLenNone..FastEncode
11049void fasttest::TrvSeqLenNone_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqLenNone& parent) {
11050 // Value unsigned none mandatory
11051 lib_fast::EncodeUnsigned(buf,parent.Value,false);
11052 (void)state;//only to avoid -Wunused-parameter
11053}
11054
11055// --- fasttest.TrvSeqLenNone..FastDecode
11056bool fasttest::TrvSeqLenNone_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqLenNone& parent) {
11057 bool ok = true;
11058 // Value unsigned none mandatory
11059 if (ok) {
11060 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
11061 if (!ok) {
11062 state.error << "fasttest.TrvSeqLenNone.Value: bad Unsigned" << eol;
11063 }
11064 }
11065 return ok;
11066}
11067
11068// --- fasttest.TrvSeqLenNone..FixEncode
11069void fasttest::TrvSeqLenNone_FixEncode(cstring& buf, fasttest::TrvSeqLenNone& parent, char soh) {
11070 buf << "3=" << parent.Value << soh;
11071}
11072
11073// --- fasttest.SeqTrvLenNone.base.CopyOut
11074// Copy fields out of row
11075void fasttest::parent_CopyOut(fasttest::SeqTrvLenNone &row, fasttest::TemplateHeader &out) {
11076 // length: field value is computed
11077 // id: field value is computed
11078 (void)row;//only to avoid -Wunused-parameter
11079 (void)out;//only to avoid -Wunused-parameter
11080}
11081
11082// --- fasttest.SeqTrvLenNone.TrvSeqLenNone.Getary
11083// Access var-length portion as an aryptr. Length is determined from one of the fields.
11084algo::aryptr<fasttest::TrvSeqLenNone> fasttest::TrvSeqLenNone_Getary(fasttest::SeqTrvLenNone& parent) {
11085 return algo::aryptr<fasttest::TrvSeqLenNone>(TrvSeqLenNone_Addr(parent), TrvSeqLenNone_N(parent));
11086}
11087
11088// --- fasttest.SeqTrvLenNone.TrvSeqLenNone.Addr
11089fasttest::TrvSeqLenNone* fasttest::TrvSeqLenNone_Addr(fasttest::SeqTrvLenNone& parent) {
11090 return (fasttest::TrvSeqLenNone*)((u8*)&parent + sizeof(fasttest::SeqTrvLenNone)); // address of varlen portion
11091}
11092
11093// --- fasttest.SeqTrvLenNone.TrvSeqLenNone.ReadStrptrMaybe
11094// Convert string to field. Return success value
11095bool fasttest::TrvSeqLenNone_ReadStrptrMaybe(fasttest::SeqTrvLenNone& parent, algo::strptr in_str) {
11096 bool retval = true;
11097 if (algo_lib::_db.varlenbuf) {
11098 fasttest::TrvSeqLenNone *TrvSeqLenNone_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::TrvSeqLenNone)).elems) fasttest::TrvSeqLenNone;
11099 retval = fasttest::TrvSeqLenNone_ReadStrptrMaybe(*TrvSeqLenNone_tmp, in_str);
11100 }
11101 (void)parent;//only to avoid -Wunused-parameter
11102 return retval;
11103}
11104
11105// --- fasttest.SeqTrvLenNone..ReadFieldMaybe
11106bool fasttest::SeqTrvLenNone_ReadFieldMaybe(fasttest::SeqTrvLenNone& parent, algo::strptr field, algo::strptr strval) {
11107 bool retval = true;
11108 fasttest::FieldId field_id;
11109 (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
11110 switch(field_id) {
11111 case fasttest_FieldId_base: {
11112 retval = false;
11113 break;
11114 }
11115 case fasttest_FieldId_length: {
11116 retval = false;
11117 break;
11118 }
11119 case fasttest_FieldId_id: {
11120 retval = false;
11121 break;
11122 }
11123 case fasttest_FieldId_TrvSeqLenNone: {
11124 retval = TrvSeqLenNone_ReadStrptrMaybe(parent, strval);
11125 break;
11126 }
11127 default: break;
11128 }
11129 if (!retval) {
11130 algo_lib::AppendErrtext("attr",field);
11131 }
11132 return retval;
11133}
11134
11135// --- fasttest.SeqTrvLenNone..ReadStrptrMaybe
11136// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
11137// Read fields of fasttest::SeqTrvLenNone from an ascii string.
11138// The format of the string is an ssim Tuple
11139bool fasttest::SeqTrvLenNone_ReadStrptrMaybe(fasttest::SeqTrvLenNone &parent, algo::strptr in_str) {
11140 bool retval = true;
11141 retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenNone");
11142 ind_beg(algo::Attr_curs, attr, in_str) {
11143 retval = retval && SeqTrvLenNone_ReadFieldMaybe(parent, attr.name, attr.value);
11144 }ind_end;
11145 return retval;
11146}
11147
11148// --- fasttest.SeqTrvLenNone..Print
11149// print string representation of ROW to string STR
11150// cfmt:fasttest.SeqTrvLenNone.String printfmt:Tuple
11151void fasttest::SeqTrvLenNone_Print(fasttest::SeqTrvLenNone& row, algo::cstring& str) {
11152 algo::tempstr temp;
11153 str << "fasttest.SeqTrvLenNone";
11154
11155 ind_beg(SeqTrvLenNone_TrvSeqLenNone_curs,TrvSeqLenNone,row) {
11156 fasttest::TrvSeqLenNone_Print(TrvSeqLenNone, temp);
11157 tempstr name;
11158 name << "TrvSeqLenNone.";
11159 name << ind_curs(TrvSeqLenNone).index;
11160 PrintAttrSpaceReset(str, name, temp);
11161 }ind_end;
11162}
11163
11164// --- fasttest.SeqTrvLenNone..FastEncode
11165void fasttest::SeqTrvLenNone_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenNone& parent) {
11166 int index = ary_N(buf);
11167 u64 pmap(0);
11168 if (!tid_AssignedQ(state) || parent.id != state.tid) {
11169 lib_fast::EncodeUnsigned(buf,parent.id,false);
11170 lib_fast::SetPmapBit(pmap,0);
11171 }
11172 tid_SetAssigned(state);
11173 state.tid = parent.id;
11174 // TrvSeqLenNone sequence none mandatory
11175 {
11176 u32 length = TrvSeqLenNone_N(parent);
11177 lib_fast::EncodeUnsigned(buf,length,false);
11178 ind_beg(SeqTrvLenNone_TrvSeqLenNone_curs,elem,parent) {
11179 TrvSeqLenNone_FastEncode(buf,state,elem);
11180 }ind_end;
11181 }
11182 lib_fast::InsertPmap(buf,index,pmap);
11183}
11184
11185// --- fasttest.SeqTrvLenNone..FastDecode
11186bool fasttest::SeqTrvLenNone_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenNone& parent) {
11187 bool ok = true;
11188 // TrvSeqLenNone sequence none mandatory
11189 if (ok) {
11190 u32 length(0);
11191 ok = lib_fast::DecodeUnsigned(from,length,false);
11192 if (!ok) {
11193 state.error << "fasttest.SeqTrvLenNone.TrvSeqLenNone: bad Unsigned" << eol;
11194 }
11195 if (!ok) {
11196 state.error << "fasttest.SeqTrvLenNone.TrvSeqLenNone: bad length" << eol;
11197 }
11198 for (unsigned i=0; ok && i<length; ++i) {
11199 TrvSeqLenNone &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) TrvSeqLenNone;
11200 ok = TrvSeqLenNone_FastDecode(from,state,seq);
11201 if (!ok) {
11202 state.error << "fasttest.SeqTrvLenNone.TrvSeqLenNone: element #"<< i+1 << eol;
11203 }
11204 }
11205 }
11206 (void)pmap;//only to avoid -Wunused-parameter
11207 (void)parent;//only to avoid -Wunused-parameter
11208 return ok;
11209}
11210
11211// --- fasttest.SeqTrvLenNone..FixEncode
11212void fasttest::SeqTrvLenNone_FixEncode(cstring& buf, fasttest::SeqTrvLenNone& parent, char soh) {
11213 {
11214 u32 length = TrvSeqLenNone_N(parent);
11215 if (length) {
11216 buf << "2=" << length << soh;
11217 }
11218 }
11219 ind_beg(SeqTrvLenNone_TrvSeqLenNone_curs,elem,parent) {
11220 TrvSeqLenNone_FixEncode(buf,elem,soh);
11221 }ind_end;
11222}
11223
11224// --- fasttest.TrvSeqLenNoneOpt..ReadFieldMaybe
11225bool fasttest::TrvSeqLenNoneOpt_ReadFieldMaybe(fasttest::TrvSeqLenNoneOpt& parent, algo::strptr field, algo::strptr strval) {
11226 bool retval = true;
11227 fasttest::FieldId field_id;
11228 (void)value_SetStrptrMaybe(field_id,field);
11229 switch(field_id) {
11230 case fasttest_FieldId_Value: {
11231 retval = u32_ReadStrptrMaybe(parent.Value, strval);
11232 break;
11233 }
11234 default: break;
11235 }
11236 if (!retval) {
11237 algo_lib::AppendErrtext("attr",field);
11238 }
11239 return retval;
11240}
11241
11242// --- fasttest.TrvSeqLenNoneOpt..ReadStrptrMaybe
11243// Read fields of fasttest::TrvSeqLenNoneOpt from an ascii string.
11244// The format of the string is an ssim Tuple
11245bool fasttest::TrvSeqLenNoneOpt_ReadStrptrMaybe(fasttest::TrvSeqLenNoneOpt &parent, algo::strptr in_str) {
11246 bool retval = true;
11247 retval = algo::StripTypeTag(in_str, "fasttest.TrvSeqLenNoneOpt");
11248 ind_beg(algo::Attr_curs, attr, in_str) {
11249 retval = retval && TrvSeqLenNoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
11250 }ind_end;
11251 return retval;
11252}
11253
11254// --- fasttest.TrvSeqLenNoneOpt..Print
11255// print string representation of ROW to string STR
11256// cfmt:fasttest.TrvSeqLenNoneOpt.String printfmt:Tuple
11257void fasttest::TrvSeqLenNoneOpt_Print(fasttest::TrvSeqLenNoneOpt& row, algo::cstring& str) {
11258 algo::tempstr temp;
11259 str << "fasttest.TrvSeqLenNoneOpt";
11260
11261 u32_Print(row.Value, temp);
11262 PrintAttrSpaceReset(str,"Value", temp);
11263}
11264
11265// --- fasttest.TrvSeqLenNoneOpt..FastEncode
11266void fasttest::TrvSeqLenNoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::TrvSeqLenNoneOpt& parent) {
11267 // Value unsigned none mandatory
11268 lib_fast::EncodeUnsigned(buf,parent.Value,false);
11269 (void)state;//only to avoid -Wunused-parameter
11270}
11271
11272// --- fasttest.TrvSeqLenNoneOpt..FastDecode
11273bool fasttest::TrvSeqLenNoneOpt_FastDecode(algo::memptr& from, FastState& state, fasttest::TrvSeqLenNoneOpt& parent) {
11274 bool ok = true;
11275 // Value unsigned none mandatory
11276 if (ok) {
11277 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
11278 if (!ok) {
11279 state.error << "fasttest.TrvSeqLenNoneOpt.Value: bad Unsigned" << eol;
11280 }
11281 }
11282 return ok;
11283}
11284
11285// --- fasttest.TrvSeqLenNoneOpt..FixEncode
11286void fasttest::TrvSeqLenNoneOpt_FixEncode(cstring& buf, fasttest::TrvSeqLenNoneOpt& parent, char soh) {
11287 buf << "3=" << parent.Value << soh;
11288}
11289
11290// --- fasttest.SeqTrvLenNoneOpt.base.CopyOut
11291// Copy fields out of row
11292void fasttest::parent_CopyOut(fasttest::SeqTrvLenNoneOpt &row, fasttest::TemplateHeader &out) {
11293 // length: field value is computed
11294 // id: field value is computed
11295 (void)row;//only to avoid -Wunused-parameter
11296 (void)out;//only to avoid -Wunused-parameter
11297}
11298
11299// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt.Getary
11300// Access var-length portion as an aryptr. Length is determined from one of the fields.
11301algo::aryptr<fasttest::TrvSeqLenNoneOpt> fasttest::TrvSeqLenNoneOpt_Getary(fasttest::SeqTrvLenNoneOpt& parent) {
11302 return algo::aryptr<fasttest::TrvSeqLenNoneOpt>(TrvSeqLenNoneOpt_Addr(parent), TrvSeqLenNoneOpt_N(parent));
11303}
11304
11305// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt.Addr
11306fasttest::TrvSeqLenNoneOpt* fasttest::TrvSeqLenNoneOpt_Addr(fasttest::SeqTrvLenNoneOpt& parent) {
11307 return (fasttest::TrvSeqLenNoneOpt*)((u8*)&parent + sizeof(fasttest::SeqTrvLenNoneOpt)); // address of varlen portion
11308}
11309
11310// --- fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt.ReadStrptrMaybe
11311// Convert string to field. Return success value
11312bool fasttest::TrvSeqLenNoneOpt_ReadStrptrMaybe(fasttest::SeqTrvLenNoneOpt& parent, algo::strptr in_str) {
11313 bool retval = true;
11314 if (algo_lib::_db.varlenbuf) {
11315 fasttest::TrvSeqLenNoneOpt *TrvSeqLenNoneOpt_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::TrvSeqLenNoneOpt)).elems) fasttest::TrvSeqLenNoneOpt;
11316 retval = fasttest::TrvSeqLenNoneOpt_ReadStrptrMaybe(*TrvSeqLenNoneOpt_tmp, in_str);
11317 }
11318 (void)parent;//only to avoid -Wunused-parameter
11319 return retval;
11320}
11321
11322// --- fasttest.SeqTrvLenNoneOpt..ReadFieldMaybe
11323bool fasttest::SeqTrvLenNoneOpt_ReadFieldMaybe(fasttest::SeqTrvLenNoneOpt& parent, algo::strptr field, algo::strptr strval) {
11324 bool retval = true;
11325 fasttest::FieldId field_id;
11326 (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
11327 switch(field_id) {
11328 case fasttest_FieldId_base: {
11329 retval = false;
11330 break;
11331 }
11332 case fasttest_FieldId_length: {
11333 retval = false;
11334 break;
11335 }
11336 case fasttest_FieldId_id: {
11337 retval = false;
11338 break;
11339 }
11340 case fasttest_FieldId_TrvSeqLenNoneOpt: {
11341 retval = TrvSeqLenNoneOpt_ReadStrptrMaybe(parent, strval);
11342 break;
11343 }
11344 default: break;
11345 }
11346 if (!retval) {
11347 algo_lib::AppendErrtext("attr",field);
11348 }
11349 return retval;
11350}
11351
11352// --- fasttest.SeqTrvLenNoneOpt..ReadStrptrMaybe
11353// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
11354// Read fields of fasttest::SeqTrvLenNoneOpt from an ascii string.
11355// The format of the string is an ssim Tuple
11356bool fasttest::SeqTrvLenNoneOpt_ReadStrptrMaybe(fasttest::SeqTrvLenNoneOpt &parent, algo::strptr in_str) {
11357 bool retval = true;
11358 retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvLenNoneOpt");
11359 ind_beg(algo::Attr_curs, attr, in_str) {
11360 retval = retval && SeqTrvLenNoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
11361 }ind_end;
11362 return retval;
11363}
11364
11365// --- fasttest.SeqTrvLenNoneOpt..Print
11366// print string representation of ROW to string STR
11367// cfmt:fasttest.SeqTrvLenNoneOpt.String printfmt:Tuple
11368void fasttest::SeqTrvLenNoneOpt_Print(fasttest::SeqTrvLenNoneOpt& row, algo::cstring& str) {
11369 algo::tempstr temp;
11370 str << "fasttest.SeqTrvLenNoneOpt";
11371
11372 ind_beg(SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs,TrvSeqLenNoneOpt,row) {
11373 fasttest::TrvSeqLenNoneOpt_Print(TrvSeqLenNoneOpt, temp);
11374 tempstr name;
11375 name << "TrvSeqLenNoneOpt.";
11376 name << ind_curs(TrvSeqLenNoneOpt).index;
11377 PrintAttrSpaceReset(str, name, temp);
11378 }ind_end;
11379}
11380
11381// --- fasttest.SeqTrvLenNoneOpt..FastEncode
11382void fasttest::SeqTrvLenNoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvLenNoneOpt& parent) {
11383 int index = ary_N(buf);
11384 u64 pmap(0);
11385 if (!tid_AssignedQ(state) || parent.id != state.tid) {
11386 lib_fast::EncodeUnsigned(buf,parent.id,false);
11387 lib_fast::SetPmapBit(pmap,0);
11388 }
11389 tid_SetAssigned(state);
11390 state.tid = parent.id;
11391 // TrvSeqLenNoneOpt sequence none optional
11392 {
11393 u32 length = TrvSeqLenNoneOpt_N(parent);
11394 if (length) {
11395 lib_fast::EncodeUnsigned(buf,length,true);
11396 } else {
11397 lib_fast::EncodeNull(buf);
11398 }
11399 ind_beg(SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs,elem,parent) {
11400 TrvSeqLenNoneOpt_FastEncode(buf,state,elem);
11401 }ind_end;
11402 }
11403 lib_fast::InsertPmap(buf,index,pmap);
11404}
11405
11406// --- fasttest.SeqTrvLenNoneOpt..FastDecode
11407bool fasttest::SeqTrvLenNoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvLenNoneOpt& parent) {
11408 bool ok = true;
11409 // TrvSeqLenNoneOpt sequence none optional
11410 if (ok) {
11411 u32 length(0);
11412 bool prs = !lib_fast::DecodeNull(from);
11413 if (prs) {
11414 ok = lib_fast::DecodeUnsigned(from,length,true);
11415 if (!ok) {
11416 state.error << "fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt: bad Unsigned" << eol;
11417 }
11418 }
11419 ;
11420 if (!ok) {
11421 state.error << "fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt: bad length" << eol;
11422 }
11423 length = prs ? length : 0;
11424 for (unsigned i=0; ok && i<length; ++i) {
11425 TrvSeqLenNoneOpt &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) TrvSeqLenNoneOpt;
11426 ok = TrvSeqLenNoneOpt_FastDecode(from,state,seq);
11427 if (!ok) {
11428 state.error << "fasttest.SeqTrvLenNoneOpt.TrvSeqLenNoneOpt: element #"<< i+1 << eol;
11429 }
11430 }
11431 }
11432 (void)pmap;//only to avoid -Wunused-parameter
11433 (void)parent;//only to avoid -Wunused-parameter
11434 return ok;
11435}
11436
11437// --- fasttest.SeqTrvLenNoneOpt..FixEncode
11438void fasttest::SeqTrvLenNoneOpt_FixEncode(cstring& buf, fasttest::SeqTrvLenNoneOpt& parent, char soh) {
11439 {
11440 u32 length = TrvSeqLenNoneOpt_N(parent);
11441 if (length) {
11442 buf << "2=" << length << soh;
11443 }
11444 }
11445 ind_beg(SeqTrvLenNoneOpt_TrvSeqLenNoneOpt_curs,elem,parent) {
11446 TrvSeqLenNoneOpt_FixEncode(buf,elem,soh);
11447 }ind_end;
11448}
11449
11450// --- fasttest.SeqTrvOpt.base.CopyOut
11451// Copy fields out of row
11452void fasttest::parent_CopyOut(fasttest::SeqTrvOpt &row, fasttest::TemplateHeader &out) {
11453 // length: field value is computed
11454 // id: field value is computed
11455 (void)row;//only to avoid -Wunused-parameter
11456 (void)out;//only to avoid -Wunused-parameter
11457}
11458
11459// --- fasttest.SeqTrvOpt.OptTrvSeq.Getary
11460// Access var-length portion as an aryptr. Length is determined from one of the fields.
11461algo::aryptr<fasttest::OptTrvSeq> fasttest::OptTrvSeq_Getary(fasttest::SeqTrvOpt& parent) {
11462 return algo::aryptr<fasttest::OptTrvSeq>(OptTrvSeq_Addr(parent), OptTrvSeq_N(parent));
11463}
11464
11465// --- fasttest.SeqTrvOpt.OptTrvSeq.Addr
11466fasttest::OptTrvSeq* fasttest::OptTrvSeq_Addr(fasttest::SeqTrvOpt& parent) {
11467 return (fasttest::OptTrvSeq*)((u8*)&parent + sizeof(fasttest::SeqTrvOpt)); // address of varlen portion
11468}
11469
11470// --- fasttest.SeqTrvOpt.OptTrvSeq.ReadStrptrMaybe
11471// Convert string to field. Return success value
11472bool fasttest::OptTrvSeq_ReadStrptrMaybe(fasttest::SeqTrvOpt& parent, algo::strptr in_str) {
11473 bool retval = true;
11474 if (algo_lib::_db.varlenbuf) {
11475 fasttest::OptTrvSeq *OptTrvSeq_tmp = new(ary_AllocN(*algo_lib::_db.varlenbuf, sizeof(fasttest::OptTrvSeq)).elems) fasttest::OptTrvSeq;
11476 retval = fasttest::OptTrvSeq_ReadStrptrMaybe(*OptTrvSeq_tmp, in_str);
11477 }
11478 (void)parent;//only to avoid -Wunused-parameter
11479 return retval;
11480}
11481
11482// --- fasttest.SeqTrvOpt..ReadFieldMaybe
11483bool fasttest::SeqTrvOpt_ReadFieldMaybe(fasttest::SeqTrvOpt& parent, algo::strptr field, algo::strptr strval) {
11484 bool retval = true;
11485 fasttest::FieldId field_id;
11486 (void)value_SetStrptrMaybe(field_id,algo::Pathcomp(field, ".LL"));
11487 switch(field_id) {
11488 case fasttest_FieldId_base: {
11489 retval = false;
11490 break;
11491 }
11492 case fasttest_FieldId_length: {
11493 retval = false;
11494 break;
11495 }
11496 case fasttest_FieldId_id: {
11497 retval = false;
11498 break;
11499 }
11500 case fasttest_FieldId_OptTrvSeq: {
11501 retval = OptTrvSeq_ReadStrptrMaybe(parent, strval);
11502 break;
11503 }
11504 default: break;
11505 }
11506 if (!retval) {
11507 algo_lib::AppendErrtext("attr",field);
11508 }
11509 return retval;
11510}
11511
11512// --- fasttest.SeqTrvOpt..ReadStrptrMaybe
11513// Any varlen fields are returned in algo_lib::_db.varlenbuf if set
11514// Read fields of fasttest::SeqTrvOpt from an ascii string.
11515// The format of the string is an ssim Tuple
11516bool fasttest::SeqTrvOpt_ReadStrptrMaybe(fasttest::SeqTrvOpt &parent, algo::strptr in_str) {
11517 bool retval = true;
11518 retval = algo::StripTypeTag(in_str, "fasttest.SeqTrvOpt");
11519 ind_beg(algo::Attr_curs, attr, in_str) {
11520 retval = retval && SeqTrvOpt_ReadFieldMaybe(parent, attr.name, attr.value);
11521 }ind_end;
11522 return retval;
11523}
11524
11525// --- fasttest.SeqTrvOpt..Print
11526// print string representation of ROW to string STR
11527// cfmt:fasttest.SeqTrvOpt.String printfmt:Tuple
11528void fasttest::SeqTrvOpt_Print(fasttest::SeqTrvOpt& row, algo::cstring& str) {
11529 algo::tempstr temp;
11530 str << "fasttest.SeqTrvOpt";
11531
11532 ind_beg(SeqTrvOpt_OptTrvSeq_curs,OptTrvSeq,row) {
11533 fasttest::OptTrvSeq_Print(OptTrvSeq, temp);
11534 tempstr name;
11535 name << "OptTrvSeq.";
11536 name << ind_curs(OptTrvSeq).index;
11537 PrintAttrSpaceReset(str, name, temp);
11538 }ind_end;
11539}
11540
11541// --- fasttest.SeqTrvOpt..FastEncode
11542void fasttest::SeqTrvOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::SeqTrvOpt& parent) {
11543 int index = ary_N(buf);
11544 u64 pmap(0);
11545 if (!tid_AssignedQ(state) || parent.id != state.tid) {
11546 lib_fast::EncodeUnsigned(buf,parent.id,false);
11547 lib_fast::SetPmapBit(pmap,0);
11548 }
11549 tid_SetAssigned(state);
11550 state.tid = parent.id;
11551 // OptTrvSeq sequence none optional
11552 {
11553 u32 length = OptTrvSeq_N(parent);
11554 if (length) {
11555 lib_fast::EncodeUnsigned(buf,length,true);
11556 } else {
11557 lib_fast::EncodeNull(buf);
11558 }
11559 ind_beg(SeqTrvOpt_OptTrvSeq_curs,elem,parent) {
11560 OptTrvSeq_FastEncode(buf,state,elem);
11561 }ind_end;
11562 }
11563 lib_fast::InsertPmap(buf,index,pmap);
11564}
11565
11566// --- fasttest.SeqTrvOpt..FastDecode
11567bool fasttest::SeqTrvOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::SeqTrvOpt& parent) {
11568 bool ok = true;
11569 // OptTrvSeq sequence none optional
11570 if (ok) {
11571 u32 length(0);
11572 bool prs = !lib_fast::DecodeNull(from);
11573 if (prs) {
11574 ok = lib_fast::DecodeUnsigned(from,length,true);
11575 if (!ok) {
11576 state.error << "fasttest.SeqTrvOpt.OptTrvSeq: bad Unsigned" << eol;
11577 }
11578 }
11579 ;
11580 if (!ok) {
11581 state.error << "fasttest.SeqTrvOpt.OptTrvSeq: bad length" << eol;
11582 }
11583 length = prs ? length : 0;
11584 for (unsigned i=0; ok && i<length; ++i) {
11585 OptTrvSeq &seq = *new(ary_AllocN(lib_fast::_db.varlen,sizeof seq).elems) OptTrvSeq;
11586 ok = OptTrvSeq_FastDecode(from,state,seq);
11587 if (!ok) {
11588 state.error << "fasttest.SeqTrvOpt.OptTrvSeq: element #"<< i+1 << eol;
11589 }
11590 }
11591 }
11592 (void)pmap;//only to avoid -Wunused-parameter
11593 (void)parent;//only to avoid -Wunused-parameter
11594 return ok;
11595}
11596
11597// --- fasttest.SeqTrvOpt..FixEncode
11598void fasttest::SeqTrvOpt_FixEncode(cstring& buf, fasttest::SeqTrvOpt& parent, char soh) {
11599 ind_beg(SeqTrvOpt_OptTrvSeq_curs,elem,parent) {
11600 OptTrvSeq_FixEncode(buf,elem,soh);
11601 }ind_end;
11602}
11603
11604// --- fasttest.StrConst.base.CopyOut
11605// Copy fields out of row
11606void fasttest::parent_CopyOut(fasttest::StrConst &row, fasttest::TemplateHeader &out) {
11607 // length: field value is computed
11608 // id: field value is computed
11609 (void)row;//only to avoid -Wunused-parameter
11610 (void)out;//only to avoid -Wunused-parameter
11611}
11612
11613// --- fasttest.StrConst..ReadFieldMaybe
11614bool fasttest::StrConst_ReadFieldMaybe(fasttest::StrConst& parent, algo::strptr field, algo::strptr strval) {
11615 bool retval = true;
11616 fasttest::FieldId field_id;
11617 (void)value_SetStrptrMaybe(field_id,field);
11618 switch(field_id) {
11619 case fasttest_FieldId_base: {
11620 retval = false;
11621 break;
11622 }
11623 case fasttest_FieldId_length: {
11624 retval = false;
11625 break;
11626 }
11627 case fasttest_FieldId_id: {
11628 retval = false;
11629 break;
11630 }
11631 case fasttest_FieldId_Value: {
11632 retval = true;
11633 break;
11634 }
11635 default: break;
11636 }
11637 if (!retval) {
11638 algo_lib::AppendErrtext("attr",field);
11639 }
11640 (void)parent;//only to avoid -Wunused-parameter
11641 (void)strval;//only to avoid -Wunused-parameter
11642 return retval;
11643}
11644
11645// --- fasttest.StrConst..ReadStrptrMaybe
11646// Read fields of fasttest::StrConst from an ascii string.
11647// The format of the string is an ssim Tuple
11648bool fasttest::StrConst_ReadStrptrMaybe(fasttest::StrConst &parent, algo::strptr in_str) {
11649 bool retval = true;
11650 retval = algo::StripTypeTag(in_str, "fasttest.StrConst");
11651 ind_beg(algo::Attr_curs, attr, in_str) {
11652 retval = retval && StrConst_ReadFieldMaybe(parent, attr.name, attr.value);
11653 }ind_end;
11654 return retval;
11655}
11656
11657// --- fasttest.StrConst..Print
11658// print string representation of ROW to string STR
11659// cfmt:fasttest.StrConst.String printfmt:Tuple
11660void fasttest::StrConst_Print(fasttest::StrConst& row, algo::cstring& str) {
11661 algo::tempstr temp;
11662 str << "fasttest.StrConst";
11663
11664 algo::strptr_Print(Value_Get(row), temp);
11665 PrintAttrSpaceReset(str,"Value", temp);
11666}
11667
11668// --- fasttest.StrConst..FastEncode
11669void fasttest::StrConst_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrConst& parent) {
11670 int index = ary_N(buf);
11671 u64 pmap(0);
11672 if (!tid_AssignedQ(state) || parent.id != state.tid) {
11673 lib_fast::EncodeUnsigned(buf,parent.id,false);
11674 lib_fast::SetPmapBit(pmap,0);
11675 }
11676 tid_SetAssigned(state);
11677 state.tid = parent.id;
11678 // Value string constant mandatory
11679 lib_fast::InsertPmap(buf,index,pmap);
11680}
11681
11682// --- fasttest.StrConst..FastDecode
11683bool fasttest::StrConst_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrConst& parent) {
11684 bool ok = true;
11685 // Value string constant mandatory
11686 if (ok) {
11687 }
11688 (void)from;//only to avoid -Wunused-parameter
11689 (void)pmap;//only to avoid -Wunused-parameter
11690 (void)state;//only to avoid -Wunused-parameter
11691 (void)parent;//only to avoid -Wunused-parameter
11692 return ok;
11693}
11694
11695// --- fasttest.StrConst..FixEncode
11696void fasttest::StrConst_FixEncode(cstring& buf, fasttest::StrConst& parent, char soh) {
11697 buf << "1=" << Value_Get(parent) << soh;
11698}
11699
11700// --- fasttest.StrConstOpt.base.CopyOut
11701// Copy fields out of row
11702void fasttest::parent_CopyOut(fasttest::StrConstOpt &row, fasttest::TemplateHeader &out) {
11703 // length: field value is computed
11704 // id: field value is computed
11705 (void)row;//only to avoid -Wunused-parameter
11706 (void)out;//only to avoid -Wunused-parameter
11707}
11708
11709// --- fasttest.StrConstOpt.pmask_bitcurs.Next
11710// proceed to next item
11711void fasttest::StrConstOpt_pmask_bitcurs_Next(StrConstOpt_pmask_bitcurs &curs) {
11712 ++curs.bit;
11713 int index = curs.bit / 32;
11714 int offset = curs.bit % 32;
11715 for (; index < curs.n_elems; ++index, offset = 0) {
11716 u64 rest = curs.elems[index] >> offset;
11717 if (rest) {
11718 offset += algo::u64_BitScanForward(rest);
11719 break;
11720 }
11721 }
11722 curs.bit = index * 32 + offset;
11723}
11724
11725// --- fasttest.StrConstOpt..ReadFieldMaybe
11726bool fasttest::StrConstOpt_ReadFieldMaybe(fasttest::StrConstOpt& parent, algo::strptr field, algo::strptr strval) {
11727 bool retval = true;
11728 fasttest::FieldId field_id;
11729 (void)value_SetStrptrMaybe(field_id,field);
11730 switch(field_id) {
11731 case fasttest_FieldId_base: {
11732 retval = false;
11733 break;
11734 }
11735 case fasttest_FieldId_length: {
11736 retval = false;
11737 break;
11738 }
11739 case fasttest_FieldId_id: {
11740 retval = false;
11741 break;
11742 }
11743 case fasttest_FieldId_pmask: {
11744 retval = false;
11745 break;
11746 }
11747 case fasttest_FieldId_Value: {
11748 retval = true;
11749 if (retval) {
11750 pmask_qSetBit(parent, 0);
11751 }
11752 break;
11753 }
11754 default: break;
11755 }
11756 if (!retval) {
11757 algo_lib::AppendErrtext("attr",field);
11758 }
11759 (void)strval;//only to avoid -Wunused-parameter
11760 return retval;
11761}
11762
11763// --- fasttest.StrConstOpt..ReadStrptrMaybe
11764// Read fields of fasttest::StrConstOpt from an ascii string.
11765// The format of the string is an ssim Tuple
11766bool fasttest::StrConstOpt_ReadStrptrMaybe(fasttest::StrConstOpt &parent, algo::strptr in_str) {
11767 bool retval = true;
11768 retval = algo::StripTypeTag(in_str, "fasttest.StrConstOpt");
11769 ind_beg(algo::Attr_curs, attr, in_str) {
11770 retval = retval && StrConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
11771 }ind_end;
11772 return retval;
11773}
11774
11775// --- fasttest.StrConstOpt..Print
11776// print string representation of ROW to string STR
11777// cfmt:fasttest.StrConstOpt.String printfmt:Tuple
11778void fasttest::StrConstOpt_Print(fasttest::StrConstOpt& row, algo::cstring& str) {
11779 algo::tempstr temp;
11780 str << "fasttest.StrConstOpt";
11781
11782 if (Value_PresentQ(row)) {
11783 algo::strptr_Print(Value_Get(row), temp);
11784 PrintAttrSpaceReset(str,"Value", temp);
11785 }
11786}
11787
11788// --- fasttest.StrConstOpt..FastEncode
11789void fasttest::StrConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrConstOpt& parent) {
11790 int index = ary_N(buf);
11791 u64 pmap(0);
11792 if (!tid_AssignedQ(state) || parent.id != state.tid) {
11793 lib_fast::EncodeUnsigned(buf,parent.id,false);
11794 lib_fast::SetPmapBit(pmap,0);
11795 }
11796 tid_SetAssigned(state);
11797 state.tid = parent.id;
11798 // Value string constant optional
11799 if (Value_PresentQ(parent)) {
11800 lib_fast::SetPmapBit(pmap,1);
11801 }
11802 lib_fast::InsertPmap(buf,index,pmap);
11803}
11804
11805// --- fasttest.StrConstOpt..FastDecode
11806bool fasttest::StrConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrConstOpt& parent) {
11807 bool ok = true;
11808 // Value string constant optional
11809 if (ok) {
11810 bool prs = lib_fast::GetPmapBit(pmap,1);
11811 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
11812 }
11813 (void)from;//only to avoid -Wunused-parameter
11814 (void)state;//only to avoid -Wunused-parameter
11815 return ok;
11816}
11817
11818// --- fasttest.StrConstOpt..FixEncode
11819void fasttest::StrConstOpt_FixEncode(cstring& buf, fasttest::StrConstOpt& parent, char soh) {
11820 if (Value_PresentQ(parent)) {
11821 buf << "1=" << Value_Get(parent) << soh;
11822 }
11823}
11824
11825// --- fasttest.StrCopy.base.CopyOut
11826// Copy fields out of row
11827void fasttest::parent_CopyOut(fasttest::StrCopy &row, fasttest::TemplateHeader &out) {
11828 // length: field value is computed
11829 // id: field value is computed
11830 (void)row;//only to avoid -Wunused-parameter
11831 (void)out;//only to avoid -Wunused-parameter
11832}
11833
11834// --- fasttest.StrCopy..ReadFieldMaybe
11835bool fasttest::StrCopy_ReadFieldMaybe(fasttest::StrCopy& parent, algo::strptr field, algo::strptr strval) {
11836 bool retval = true;
11837 fasttest::FieldId field_id;
11838 (void)value_SetStrptrMaybe(field_id,field);
11839 switch(field_id) {
11840 case fasttest_FieldId_base: {
11841 retval = false;
11842 break;
11843 }
11844 case fasttest_FieldId_length: {
11845 retval = false;
11846 break;
11847 }
11848 case fasttest_FieldId_id: {
11849 retval = false;
11850 break;
11851 }
11852 case fasttest_FieldId_Value55: {
11853 retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value55, strval);
11854 break;
11855 }
11856 default: break;
11857 }
11858 if (!retval) {
11859 algo_lib::AppendErrtext("attr",field);
11860 }
11861 return retval;
11862}
11863
11864// --- fasttest.StrCopy..ReadStrptrMaybe
11865// Read fields of fasttest::StrCopy from an ascii string.
11866// The format of the string is an ssim Tuple
11867bool fasttest::StrCopy_ReadStrptrMaybe(fasttest::StrCopy &parent, algo::strptr in_str) {
11868 bool retval = true;
11869 retval = algo::StripTypeTag(in_str, "fasttest.StrCopy");
11870 ind_beg(algo::Attr_curs, attr, in_str) {
11871 retval = retval && StrCopy_ReadFieldMaybe(parent, attr.name, attr.value);
11872 }ind_end;
11873 return retval;
11874}
11875
11876// --- fasttest.StrCopy..Print
11877// print string representation of ROW to string STR
11878// cfmt:fasttest.StrCopy.String printfmt:Tuple
11879void fasttest::StrCopy_Print(fasttest::StrCopy& row, algo::cstring& str) {
11880 algo::tempstr temp;
11881 str << "fasttest.StrCopy";
11882
11883 algo::Smallstr30_Print(row.Value55, temp);
11884 PrintAttrSpaceReset(str,"Value55", temp);
11885}
11886
11887// --- fasttest.StrCopy..FastEncode
11888void fasttest::StrCopy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrCopy& parent) {
11889 int index = ary_N(buf);
11890 u64 pmap(0);
11891 if (!tid_AssignedQ(state) || parent.id != state.tid) {
11892 lib_fast::EncodeUnsigned(buf,parent.id,false);
11893 lib_fast::SetPmapBit(pmap,0);
11894 }
11895 tid_SetAssigned(state);
11896 state.tid = parent.id;
11897 // Value55 string copy mandatory
11898 if (Value55_AssignedQ(state) ? parent.Value55 != state.Value55 : parent.Value55 != "A55") {
11899 lib_fast::EncodeString(buf,parent.Value55,false);
11900 lib_fast::SetPmapBit(pmap,1);
11901 }
11902 state.Value55 = parent.Value55;
11903 Value55_SetAssigned(state);
11904 lib_fast::InsertPmap(buf,index,pmap);
11905}
11906
11907// --- fasttest.StrCopy..FastDecode
11908bool fasttest::StrCopy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrCopy& parent) {
11909 bool ok = true;
11910 // Value55 string copy mandatory
11911 if (ok) {
11912 bool prs = lib_fast::GetPmapBit(pmap,1);
11913 if (prs) {
11914 ok = lib_fast::DecodeString(from,parent.Value55,false);
11915 if (!ok) {
11916 state.error << "fasttest.StrCopy.Value55: bad String" << eol;
11917 }
11918 } else if (Value55_AssignedQ(state)) {
11919 parent.Value55 = state.Value55;
11920 } else {
11921 parent.Value55 = "A55";
11922 }
11923 Value55_SetAssigned(state);
11924 state.Value55 = parent.Value55;
11925 }
11926 return ok;
11927}
11928
11929// --- fasttest.StrCopy..FixEncode
11930void fasttest::StrCopy_FixEncode(cstring& buf, fasttest::StrCopy& parent, char soh) {
11931 buf << "1=" << parent.Value55 << soh;
11932}
11933
11934// --- fasttest.StrCopyNull.base.CopyOut
11935// Copy fields out of row
11936void fasttest::parent_CopyOut(fasttest::StrCopyNull &row, fasttest::TemplateHeader &out) {
11937 // length: field value is computed
11938 // id: field value is computed
11939 (void)row;//only to avoid -Wunused-parameter
11940 (void)out;//only to avoid -Wunused-parameter
11941}
11942
11943// --- fasttest.StrCopyNull.Value57.ReadStrptrMaybe
11944inline static bool fasttest::Value57_ReadStrptrMaybe(fasttest::StrCopyNull &parent, algo::strptr in_str) {
11945 bool retval = true;
11946 algo::Smallstr30 Value57_tmp;
11947 retval = algo::Smallstr30_ReadStrptrMaybe(Value57_tmp, in_str);
11948 if (retval) {
11949 Value57_Set(parent, Value57_tmp);
11950 }
11951 return retval;
11952}
11953
11954// --- fasttest.StrCopyNull.pmask_bitcurs.Next
11955// proceed to next item
11956void fasttest::StrCopyNull_pmask_bitcurs_Next(StrCopyNull_pmask_bitcurs &curs) {
11957 ++curs.bit;
11958 int index = curs.bit / 32;
11959 int offset = curs.bit % 32;
11960 for (; index < curs.n_elems; ++index, offset = 0) {
11961 u64 rest = curs.elems[index] >> offset;
11962 if (rest) {
11963 offset += algo::u64_BitScanForward(rest);
11964 break;
11965 }
11966 }
11967 curs.bit = index * 32 + offset;
11968}
11969
11970// --- fasttest.StrCopyNull..ReadFieldMaybe
11971bool fasttest::StrCopyNull_ReadFieldMaybe(fasttest::StrCopyNull& parent, algo::strptr field, algo::strptr strval) {
11972 bool retval = true;
11973 fasttest::FieldId field_id;
11974 (void)value_SetStrptrMaybe(field_id,field);
11975 switch(field_id) {
11976 case fasttest_FieldId_base: {
11977 retval = false;
11978 break;
11979 }
11980 case fasttest_FieldId_length: {
11981 retval = false;
11982 break;
11983 }
11984 case fasttest_FieldId_id: {
11985 retval = false;
11986 break;
11987 }
11988 case fasttest_FieldId_pmask: {
11989 retval = false;
11990 break;
11991 }
11992 case fasttest_FieldId_Value57: {
11993 retval = Value57_ReadStrptrMaybe(parent, strval);
11994 if (retval) {
11995 pmask_qSetBit(parent, 0);
11996 }
11997 break;
11998 }
11999 default: break;
12000 }
12001 if (!retval) {
12002 algo_lib::AppendErrtext("attr",field);
12003 }
12004 return retval;
12005}
12006
12007// --- fasttest.StrCopyNull..ReadStrptrMaybe
12008// Read fields of fasttest::StrCopyNull from an ascii string.
12009// The format of the string is an ssim Tuple
12010bool fasttest::StrCopyNull_ReadStrptrMaybe(fasttest::StrCopyNull &parent, algo::strptr in_str) {
12011 bool retval = true;
12012 retval = algo::StripTypeTag(in_str, "fasttest.StrCopyNull");
12013 ind_beg(algo::Attr_curs, attr, in_str) {
12014 retval = retval && StrCopyNull_ReadFieldMaybe(parent, attr.name, attr.value);
12015 }ind_end;
12016 return retval;
12017}
12018
12019// --- fasttest.StrCopyNull..Print
12020// print string representation of ROW to string STR
12021// cfmt:fasttest.StrCopyNull.String printfmt:Tuple
12022void fasttest::StrCopyNull_Print(fasttest::StrCopyNull& row, algo::cstring& str) {
12023 algo::tempstr temp;
12024 str << "fasttest.StrCopyNull";
12025
12026 if (Value57_PresentQ(row)) {
12027 algo::Smallstr30_Print(row.Value57, temp);
12028 PrintAttrSpaceReset(str,"Value57", temp);
12029 }
12030}
12031
12032// --- fasttest.StrCopyNull..FastEncode
12033void fasttest::StrCopyNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrCopyNull& parent) {
12034 int index = ary_N(buf);
12035 u64 pmap(0);
12036 if (!tid_AssignedQ(state) || parent.id != state.tid) {
12037 lib_fast::EncodeUnsigned(buf,parent.id,false);
12038 lib_fast::SetPmapBit(pmap,0);
12039 }
12040 tid_SetAssigned(state);
12041 state.tid = parent.id;
12042 // Value57 string copy optional
12043 if (Value57_PresentQ(parent)) {
12044 if (!Value57_AssignedQ(state) || !Value57_PresentQ(state) || parent.Value57 != state.Value57 ) {
12045 lib_fast::EncodeString(buf,parent.Value57,true);
12046 lib_fast::SetPmapBit(pmap,1);
12047 }
12048 } else {
12049 if (Value57_AssignedQ(state)) {
12050 lib_fast::EncodeNull(buf);
12051 lib_fast::SetPmapBit(pmap,1);
12052 }
12053 }
12054 state.Value57 = parent.Value57;
12055 present_qSetBitVal(state,Value57_Present_GetBit(state),Value57_PresentQ(parent));
12056 Value57_SetAssigned(state);
12057 lib_fast::InsertPmap(buf,index,pmap);
12058}
12059
12060// --- fasttest.StrCopyNull..FastDecode
12061bool fasttest::StrCopyNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrCopyNull& parent) {
12062 bool ok = true;
12063 // Value57 string copy optional
12064 if (ok) {
12065 bool prs = lib_fast::GetPmapBit(pmap,1);
12066 if (prs) {
12067 prs = !lib_fast::DecodeNull(from);
12068 if (prs) {
12069 ok = lib_fast::DecodeString(from,parent.Value57,true);
12070 if (!ok) {
12071 state.error << "fasttest.StrCopyNull.Value57: bad String" << eol;
12072 }
12073 }
12074 } else if (Value57_AssignedQ(state)) {
12075 parent.Value57 = state.Value57;
12076 prs = Value57_PresentQ(state);
12077 } else {
12078 prs = false;
12079 }
12080 pmask_qSetBitVal(parent,Value57_Present_GetBit(parent),prs);
12081 Value57_SetAssigned(state);
12082 present_qSetBitVal(state,Value57_Present_GetBit(state),prs);
12083 state.Value57 = parent.Value57;
12084 }
12085 return ok;
12086}
12087
12088// --- fasttest.StrCopyNull..FixEncode
12089void fasttest::StrCopyNull_FixEncode(cstring& buf, fasttest::StrCopyNull& parent, char soh) {
12090 if (Value57_PresentQ(parent)) {
12091 buf << "1=" << parent.Value57 << soh;
12092 }
12093}
12094
12095// --- fasttest.StrCopyOpt.base.CopyOut
12096// Copy fields out of row
12097void fasttest::parent_CopyOut(fasttest::StrCopyOpt &row, fasttest::TemplateHeader &out) {
12098 // length: field value is computed
12099 // id: field value is computed
12100 (void)row;//only to avoid -Wunused-parameter
12101 (void)out;//only to avoid -Wunused-parameter
12102}
12103
12104// --- fasttest.StrCopyOpt.Value56.ReadStrptrMaybe
12105inline static bool fasttest::Value56_ReadStrptrMaybe(fasttest::StrCopyOpt &parent, algo::strptr in_str) {
12106 bool retval = true;
12107 algo::Smallstr30 Value56_tmp;
12108 retval = algo::Smallstr30_ReadStrptrMaybe(Value56_tmp, in_str);
12109 if (retval) {
12110 Value56_Set(parent, Value56_tmp);
12111 }
12112 return retval;
12113}
12114
12115// --- fasttest.StrCopyOpt.pmask_bitcurs.Next
12116// proceed to next item
12117void fasttest::StrCopyOpt_pmask_bitcurs_Next(StrCopyOpt_pmask_bitcurs &curs) {
12118 ++curs.bit;
12119 int index = curs.bit / 32;
12120 int offset = curs.bit % 32;
12121 for (; index < curs.n_elems; ++index, offset = 0) {
12122 u64 rest = curs.elems[index] >> offset;
12123 if (rest) {
12124 offset += algo::u64_BitScanForward(rest);
12125 break;
12126 }
12127 }
12128 curs.bit = index * 32 + offset;
12129}
12130
12131// --- fasttest.StrCopyOpt..ReadFieldMaybe
12132bool fasttest::StrCopyOpt_ReadFieldMaybe(fasttest::StrCopyOpt& parent, algo::strptr field, algo::strptr strval) {
12133 bool retval = true;
12134 fasttest::FieldId field_id;
12135 (void)value_SetStrptrMaybe(field_id,field);
12136 switch(field_id) {
12137 case fasttest_FieldId_base: {
12138 retval = false;
12139 break;
12140 }
12141 case fasttest_FieldId_length: {
12142 retval = false;
12143 break;
12144 }
12145 case fasttest_FieldId_id: {
12146 retval = false;
12147 break;
12148 }
12149 case fasttest_FieldId_pmask: {
12150 retval = false;
12151 break;
12152 }
12153 case fasttest_FieldId_Value56: {
12154 retval = Value56_ReadStrptrMaybe(parent, strval);
12155 if (retval) {
12156 pmask_qSetBit(parent, 0);
12157 }
12158 break;
12159 }
12160 default: break;
12161 }
12162 if (!retval) {
12163 algo_lib::AppendErrtext("attr",field);
12164 }
12165 return retval;
12166}
12167
12168// --- fasttest.StrCopyOpt..ReadStrptrMaybe
12169// Read fields of fasttest::StrCopyOpt from an ascii string.
12170// The format of the string is an ssim Tuple
12171bool fasttest::StrCopyOpt_ReadStrptrMaybe(fasttest::StrCopyOpt &parent, algo::strptr in_str) {
12172 bool retval = true;
12173 retval = algo::StripTypeTag(in_str, "fasttest.StrCopyOpt");
12174 ind_beg(algo::Attr_curs, attr, in_str) {
12175 retval = retval && StrCopyOpt_ReadFieldMaybe(parent, attr.name, attr.value);
12176 }ind_end;
12177 return retval;
12178}
12179
12180// --- fasttest.StrCopyOpt..Print
12181// print string representation of ROW to string STR
12182// cfmt:fasttest.StrCopyOpt.String printfmt:Tuple
12183void fasttest::StrCopyOpt_Print(fasttest::StrCopyOpt& row, algo::cstring& str) {
12184 algo::tempstr temp;
12185 str << "fasttest.StrCopyOpt";
12186
12187 if (Value56_PresentQ(row)) {
12188 algo::Smallstr30_Print(row.Value56, temp);
12189 PrintAttrSpaceReset(str,"Value56", temp);
12190 }
12191}
12192
12193// --- fasttest.StrCopyOpt..FastEncode
12194void fasttest::StrCopyOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrCopyOpt& parent) {
12195 int index = ary_N(buf);
12196 u64 pmap(0);
12197 if (!tid_AssignedQ(state) || parent.id != state.tid) {
12198 lib_fast::EncodeUnsigned(buf,parent.id,false);
12199 lib_fast::SetPmapBit(pmap,0);
12200 }
12201 tid_SetAssigned(state);
12202 state.tid = parent.id;
12203 // Value56 string copy optional
12204 if (Value56_PresentQ(parent)) {
12205 if (Value56_AssignedQ(state) ? !Value56_PresentQ(state) || parent.Value56 != state.Value56 : parent.Value56 != "A56") {
12206 lib_fast::EncodeString(buf,parent.Value56,true);
12207 lib_fast::SetPmapBit(pmap,1);
12208 }
12209 } else {
12210 if (Value56_AssignedQ(state) && Value56_PresentQ(state)) {
12211 lib_fast::EncodeNull(buf);
12212 lib_fast::SetPmapBit(pmap,1);
12213 }
12214 }
12215 state.Value56 = parent.Value56;
12216 present_qSetBitVal(state,Value56_Present_GetBit(state),Value56_PresentQ(parent));
12217 Value56_SetAssigned(state);
12218 lib_fast::InsertPmap(buf,index,pmap);
12219}
12220
12221// --- fasttest.StrCopyOpt..FastDecode
12222bool fasttest::StrCopyOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrCopyOpt& parent) {
12223 bool ok = true;
12224 // Value56 string copy optional
12225 if (ok) {
12226 bool prs = lib_fast::GetPmapBit(pmap,1);
12227 if (prs) {
12228 prs = !lib_fast::DecodeNull(from);
12229 if (prs) {
12230 ok = lib_fast::DecodeString(from,parent.Value56,true);
12231 if (!ok) {
12232 state.error << "fasttest.StrCopyOpt.Value56: bad String" << eol;
12233 }
12234 }
12235 } else if (Value56_AssignedQ(state)) {
12236 parent.Value56 = state.Value56;
12237 prs = Value56_PresentQ(state);
12238 } else {
12239 parent.Value56 = "A56";
12240 prs = true;
12241 }
12242 pmask_qSetBitVal(parent,Value56_Present_GetBit(parent),prs);
12243 Value56_SetAssigned(state);
12244 present_qSetBitVal(state,Value56_Present_GetBit(state),prs);
12245 state.Value56 = parent.Value56;
12246 }
12247 return ok;
12248}
12249
12250// --- fasttest.StrCopyOpt..FixEncode
12251void fasttest::StrCopyOpt_FixEncode(cstring& buf, fasttest::StrCopyOpt& parent, char soh) {
12252 if (Value56_PresentQ(parent)) {
12253 buf << "1=" << parent.Value56 << soh;
12254 }
12255}
12256
12257// --- fasttest.StrDflt.base.CopyOut
12258// Copy fields out of row
12259void fasttest::parent_CopyOut(fasttest::StrDflt &row, fasttest::TemplateHeader &out) {
12260 // length: field value is computed
12261 // id: field value is computed
12262 (void)row;//only to avoid -Wunused-parameter
12263 (void)out;//only to avoid -Wunused-parameter
12264}
12265
12266// --- fasttest.StrDflt..ReadFieldMaybe
12267bool fasttest::StrDflt_ReadFieldMaybe(fasttest::StrDflt& parent, algo::strptr field, algo::strptr strval) {
12268 bool retval = true;
12269 fasttest::FieldId field_id;
12270 (void)value_SetStrptrMaybe(field_id,field);
12271 switch(field_id) {
12272 case fasttest_FieldId_base: {
12273 retval = false;
12274 break;
12275 }
12276 case fasttest_FieldId_length: {
12277 retval = false;
12278 break;
12279 }
12280 case fasttest_FieldId_id: {
12281 retval = false;
12282 break;
12283 }
12284 case fasttest_FieldId_Value: {
12285 retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value, strval);
12286 break;
12287 }
12288 default: break;
12289 }
12290 if (!retval) {
12291 algo_lib::AppendErrtext("attr",field);
12292 }
12293 return retval;
12294}
12295
12296// --- fasttest.StrDflt..ReadStrptrMaybe
12297// Read fields of fasttest::StrDflt from an ascii string.
12298// The format of the string is an ssim Tuple
12299bool fasttest::StrDflt_ReadStrptrMaybe(fasttest::StrDflt &parent, algo::strptr in_str) {
12300 bool retval = true;
12301 retval = algo::StripTypeTag(in_str, "fasttest.StrDflt");
12302 ind_beg(algo::Attr_curs, attr, in_str) {
12303 retval = retval && StrDflt_ReadFieldMaybe(parent, attr.name, attr.value);
12304 }ind_end;
12305 return retval;
12306}
12307
12308// --- fasttest.StrDflt..Print
12309// print string representation of ROW to string STR
12310// cfmt:fasttest.StrDflt.String printfmt:Tuple
12311void fasttest::StrDflt_Print(fasttest::StrDflt& row, algo::cstring& str) {
12312 algo::tempstr temp;
12313 str << "fasttest.StrDflt";
12314
12315 algo::Smallstr30_Print(row.Value, temp);
12316 PrintAttrSpaceReset(str,"Value", temp);
12317}
12318
12319// --- fasttest.StrDflt..FastEncode
12320void fasttest::StrDflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrDflt& parent) {
12321 int index = ary_N(buf);
12322 u64 pmap(0);
12323 if (!tid_AssignedQ(state) || parent.id != state.tid) {
12324 lib_fast::EncodeUnsigned(buf,parent.id,false);
12325 lib_fast::SetPmapBit(pmap,0);
12326 }
12327 tid_SetAssigned(state);
12328 state.tid = parent.id;
12329 // Value string default mandatory
12330 if (parent.Value != "A39") {
12331 lib_fast::EncodeString(buf,parent.Value,false);
12332 lib_fast::SetPmapBit(pmap,1);
12333 }
12334 lib_fast::InsertPmap(buf,index,pmap);
12335}
12336
12337// --- fasttest.StrDflt..FastDecode
12338bool fasttest::StrDflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrDflt& parent) {
12339 bool ok = true;
12340 // Value string default mandatory
12341 if (ok) {
12342 bool prs = lib_fast::GetPmapBit(pmap,1);
12343 if (prs) {
12344 ok = lib_fast::DecodeString(from,parent.Value,false);
12345 if (!ok) {
12346 state.error << "fasttest.StrDflt.Value: bad String" << eol;
12347 }
12348 } else {
12349 parent.Value = "A39";
12350 }
12351 }
12352 return ok;
12353}
12354
12355// --- fasttest.StrDflt..FixEncode
12356void fasttest::StrDflt_FixEncode(cstring& buf, fasttest::StrDflt& parent, char soh) {
12357 buf << "1=" << parent.Value << soh;
12358}
12359
12360// --- fasttest.StrDfltNull.base.CopyOut
12361// Copy fields out of row
12362void fasttest::parent_CopyOut(fasttest::StrDfltNull &row, fasttest::TemplateHeader &out) {
12363 // length: field value is computed
12364 // id: field value is computed
12365 (void)row;//only to avoid -Wunused-parameter
12366 (void)out;//only to avoid -Wunused-parameter
12367}
12368
12369// --- fasttest.StrDfltNull.Value.ReadStrptrMaybe
12370inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::StrDfltNull &parent, algo::strptr in_str) {
12371 bool retval = true;
12372 algo::Smallstr30 Value_tmp;
12373 retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
12374 if (retval) {
12375 Value_Set(parent, Value_tmp);
12376 }
12377 return retval;
12378}
12379
12380// --- fasttest.StrDfltNull.pmask_bitcurs.Next
12381// proceed to next item
12382void fasttest::StrDfltNull_pmask_bitcurs_Next(StrDfltNull_pmask_bitcurs &curs) {
12383 ++curs.bit;
12384 int index = curs.bit / 32;
12385 int offset = curs.bit % 32;
12386 for (; index < curs.n_elems; ++index, offset = 0) {
12387 u64 rest = curs.elems[index] >> offset;
12388 if (rest) {
12389 offset += algo::u64_BitScanForward(rest);
12390 break;
12391 }
12392 }
12393 curs.bit = index * 32 + offset;
12394}
12395
12396// --- fasttest.StrDfltNull..ReadFieldMaybe
12397bool fasttest::StrDfltNull_ReadFieldMaybe(fasttest::StrDfltNull& parent, algo::strptr field, algo::strptr strval) {
12398 bool retval = true;
12399 fasttest::FieldId field_id;
12400 (void)value_SetStrptrMaybe(field_id,field);
12401 switch(field_id) {
12402 case fasttest_FieldId_base: {
12403 retval = false;
12404 break;
12405 }
12406 case fasttest_FieldId_length: {
12407 retval = false;
12408 break;
12409 }
12410 case fasttest_FieldId_id: {
12411 retval = false;
12412 break;
12413 }
12414 case fasttest_FieldId_pmask: {
12415 retval = false;
12416 break;
12417 }
12418 case fasttest_FieldId_Value: {
12419 retval = Value_ReadStrptrMaybe(parent, strval);
12420 if (retval) {
12421 pmask_qSetBit(parent, 0);
12422 }
12423 break;
12424 }
12425 default: break;
12426 }
12427 if (!retval) {
12428 algo_lib::AppendErrtext("attr",field);
12429 }
12430 return retval;
12431}
12432
12433// --- fasttest.StrDfltNull..ReadStrptrMaybe
12434// Read fields of fasttest::StrDfltNull from an ascii string.
12435// The format of the string is an ssim Tuple
12436bool fasttest::StrDfltNull_ReadStrptrMaybe(fasttest::StrDfltNull &parent, algo::strptr in_str) {
12437 bool retval = true;
12438 retval = algo::StripTypeTag(in_str, "fasttest.StrDfltNull");
12439 ind_beg(algo::Attr_curs, attr, in_str) {
12440 retval = retval && StrDfltNull_ReadFieldMaybe(parent, attr.name, attr.value);
12441 }ind_end;
12442 return retval;
12443}
12444
12445// --- fasttest.StrDfltNull..Print
12446// print string representation of ROW to string STR
12447// cfmt:fasttest.StrDfltNull.String printfmt:Tuple
12448void fasttest::StrDfltNull_Print(fasttest::StrDfltNull& row, algo::cstring& str) {
12449 algo::tempstr temp;
12450 str << "fasttest.StrDfltNull";
12451
12452 if (Value_PresentQ(row)) {
12453 algo::Smallstr30_Print(row.Value, temp);
12454 PrintAttrSpaceReset(str,"Value", temp);
12455 }
12456}
12457
12458// --- fasttest.StrDfltNull..FastEncode
12459void fasttest::StrDfltNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrDfltNull& parent) {
12460 int index = ary_N(buf);
12461 u64 pmap(0);
12462 if (!tid_AssignedQ(state) || parent.id != state.tid) {
12463 lib_fast::EncodeUnsigned(buf,parent.id,false);
12464 lib_fast::SetPmapBit(pmap,0);
12465 }
12466 tid_SetAssigned(state);
12467 state.tid = parent.id;
12468 // Value string default optional
12469 if (Value_PresentQ(parent)) {
12470 lib_fast::EncodeString(buf,parent.Value,true);
12471 lib_fast::SetPmapBit(pmap,1);
12472 }
12473 lib_fast::InsertPmap(buf,index,pmap);
12474}
12475
12476// --- fasttest.StrDfltNull..FastDecode
12477bool fasttest::StrDfltNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrDfltNull& parent) {
12478 bool ok = true;
12479 // Value string default optional
12480 if (ok) {
12481 bool prs = lib_fast::GetPmapBit(pmap,1);
12482 if (prs) {
12483 prs = !lib_fast::DecodeNull(from);
12484 if (prs) {
12485 ok = lib_fast::DecodeString(from,parent.Value,true);
12486 if (!ok) {
12487 state.error << "fasttest.StrDfltNull.Value: bad String" << eol;
12488 }
12489 }
12490 } else {
12491 }
12492 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
12493 }
12494 return ok;
12495}
12496
12497// --- fasttest.StrDfltNull..FixEncode
12498void fasttest::StrDfltNull_FixEncode(cstring& buf, fasttest::StrDfltNull& parent, char soh) {
12499 if (Value_PresentQ(parent)) {
12500 buf << "1=" << parent.Value << soh;
12501 }
12502}
12503
12504// --- fasttest.StrDfltOpt.base.CopyOut
12505// Copy fields out of row
12506void fasttest::parent_CopyOut(fasttest::StrDfltOpt &row, fasttest::TemplateHeader &out) {
12507 // length: field value is computed
12508 // id: field value is computed
12509 (void)row;//only to avoid -Wunused-parameter
12510 (void)out;//only to avoid -Wunused-parameter
12511}
12512
12513// --- fasttest.StrDfltOpt.Value.ReadStrptrMaybe
12514inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::StrDfltOpt &parent, algo::strptr in_str) {
12515 bool retval = true;
12516 algo::Smallstr30 Value_tmp;
12517 retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
12518 if (retval) {
12519 Value_Set(parent, Value_tmp);
12520 }
12521 return retval;
12522}
12523
12524// --- fasttest.StrDfltOpt.pmask_bitcurs.Next
12525// proceed to next item
12526void fasttest::StrDfltOpt_pmask_bitcurs_Next(StrDfltOpt_pmask_bitcurs &curs) {
12527 ++curs.bit;
12528 int index = curs.bit / 32;
12529 int offset = curs.bit % 32;
12530 for (; index < curs.n_elems; ++index, offset = 0) {
12531 u64 rest = curs.elems[index] >> offset;
12532 if (rest) {
12533 offset += algo::u64_BitScanForward(rest);
12534 break;
12535 }
12536 }
12537 curs.bit = index * 32 + offset;
12538}
12539
12540// --- fasttest.StrDfltOpt..ReadFieldMaybe
12541bool fasttest::StrDfltOpt_ReadFieldMaybe(fasttest::StrDfltOpt& parent, algo::strptr field, algo::strptr strval) {
12542 bool retval = true;
12543 fasttest::FieldId field_id;
12544 (void)value_SetStrptrMaybe(field_id,field);
12545 switch(field_id) {
12546 case fasttest_FieldId_base: {
12547 retval = false;
12548 break;
12549 }
12550 case fasttest_FieldId_length: {
12551 retval = false;
12552 break;
12553 }
12554 case fasttest_FieldId_id: {
12555 retval = false;
12556 break;
12557 }
12558 case fasttest_FieldId_pmask: {
12559 retval = false;
12560 break;
12561 }
12562 case fasttest_FieldId_Value: {
12563 retval = Value_ReadStrptrMaybe(parent, strval);
12564 if (retval) {
12565 pmask_qSetBit(parent, 0);
12566 }
12567 break;
12568 }
12569 default: break;
12570 }
12571 if (!retval) {
12572 algo_lib::AppendErrtext("attr",field);
12573 }
12574 return retval;
12575}
12576
12577// --- fasttest.StrDfltOpt..ReadStrptrMaybe
12578// Read fields of fasttest::StrDfltOpt from an ascii string.
12579// The format of the string is an ssim Tuple
12580bool fasttest::StrDfltOpt_ReadStrptrMaybe(fasttest::StrDfltOpt &parent, algo::strptr in_str) {
12581 bool retval = true;
12582 retval = algo::StripTypeTag(in_str, "fasttest.StrDfltOpt");
12583 ind_beg(algo::Attr_curs, attr, in_str) {
12584 retval = retval && StrDfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
12585 }ind_end;
12586 return retval;
12587}
12588
12589// --- fasttest.StrDfltOpt..Print
12590// print string representation of ROW to string STR
12591// cfmt:fasttest.StrDfltOpt.String printfmt:Tuple
12592void fasttest::StrDfltOpt_Print(fasttest::StrDfltOpt& row, algo::cstring& str) {
12593 algo::tempstr temp;
12594 str << "fasttest.StrDfltOpt";
12595
12596 if (Value_PresentQ(row)) {
12597 algo::Smallstr30_Print(row.Value, temp);
12598 PrintAttrSpaceReset(str,"Value", temp);
12599 }
12600}
12601
12602// --- fasttest.StrDfltOpt..FastEncode
12603void fasttest::StrDfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrDfltOpt& parent) {
12604 int index = ary_N(buf);
12605 u64 pmap(0);
12606 if (!tid_AssignedQ(state) || parent.id != state.tid) {
12607 lib_fast::EncodeUnsigned(buf,parent.id,false);
12608 lib_fast::SetPmapBit(pmap,0);
12609 }
12610 tid_SetAssigned(state);
12611 state.tid = parent.id;
12612 // Value string default optional
12613 if (Value_PresentQ(parent)) {
12614 if (parent.Value != "A40") {
12615 lib_fast::EncodeString(buf,parent.Value,true);
12616 lib_fast::SetPmapBit(pmap,1);
12617 }
12618 } else {
12619 lib_fast::EncodeNull(buf);
12620 lib_fast::SetPmapBit(pmap,1);
12621 }
12622 lib_fast::InsertPmap(buf,index,pmap);
12623}
12624
12625// --- fasttest.StrDfltOpt..FastDecode
12626bool fasttest::StrDfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrDfltOpt& parent) {
12627 bool ok = true;
12628 // Value string default optional
12629 if (ok) {
12630 bool prs = lib_fast::GetPmapBit(pmap,1);
12631 if (prs) {
12632 prs = !lib_fast::DecodeNull(from);
12633 if (prs) {
12634 ok = lib_fast::DecodeString(from,parent.Value,true);
12635 if (!ok) {
12636 state.error << "fasttest.StrDfltOpt.Value: bad String" << eol;
12637 }
12638 }
12639 } else {
12640 parent.Value = "A40";
12641 prs = true;
12642 }
12643 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
12644 }
12645 return ok;
12646}
12647
12648// --- fasttest.StrDfltOpt..FixEncode
12649void fasttest::StrDfltOpt_FixEncode(cstring& buf, fasttest::StrDfltOpt& parent, char soh) {
12650 if (Value_PresentQ(parent)) {
12651 buf << "1=" << parent.Value << soh;
12652 }
12653}
12654
12655// --- fasttest.StrNone.base.CopyOut
12656// Copy fields out of row
12657void fasttest::parent_CopyOut(fasttest::StrNone &row, fasttest::TemplateHeader &out) {
12658 // length: field value is computed
12659 // id: field value is computed
12660 (void)row;//only to avoid -Wunused-parameter
12661 (void)out;//only to avoid -Wunused-parameter
12662}
12663
12664// --- fasttest.StrNone..ReadFieldMaybe
12665bool fasttest::StrNone_ReadFieldMaybe(fasttest::StrNone& parent, algo::strptr field, algo::strptr strval) {
12666 bool retval = true;
12667 fasttest::FieldId field_id;
12668 (void)value_SetStrptrMaybe(field_id,field);
12669 switch(field_id) {
12670 case fasttest_FieldId_base: {
12671 retval = false;
12672 break;
12673 }
12674 case fasttest_FieldId_length: {
12675 retval = false;
12676 break;
12677 }
12678 case fasttest_FieldId_id: {
12679 retval = false;
12680 break;
12681 }
12682 case fasttest_FieldId_Value: {
12683 retval = algo::Smallstr30_ReadStrptrMaybe(parent.Value, strval);
12684 break;
12685 }
12686 default: break;
12687 }
12688 if (!retval) {
12689 algo_lib::AppendErrtext("attr",field);
12690 }
12691 return retval;
12692}
12693
12694// --- fasttest.StrNone..ReadStrptrMaybe
12695// Read fields of fasttest::StrNone from an ascii string.
12696// The format of the string is an ssim Tuple
12697bool fasttest::StrNone_ReadStrptrMaybe(fasttest::StrNone &parent, algo::strptr in_str) {
12698 bool retval = true;
12699 retval = algo::StripTypeTag(in_str, "fasttest.StrNone");
12700 ind_beg(algo::Attr_curs, attr, in_str) {
12701 retval = retval && StrNone_ReadFieldMaybe(parent, attr.name, attr.value);
12702 }ind_end;
12703 return retval;
12704}
12705
12706// --- fasttest.StrNone..Print
12707// print string representation of ROW to string STR
12708// cfmt:fasttest.StrNone.String printfmt:Tuple
12709void fasttest::StrNone_Print(fasttest::StrNone& row, algo::cstring& str) {
12710 algo::tempstr temp;
12711 str << "fasttest.StrNone";
12712
12713 algo::Smallstr30_Print(row.Value, temp);
12714 PrintAttrSpaceReset(str,"Value", temp);
12715}
12716
12717// --- fasttest.StrNone..FastEncode
12718void fasttest::StrNone_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrNone& parent) {
12719 int index = ary_N(buf);
12720 u64 pmap(0);
12721 if (!tid_AssignedQ(state) || parent.id != state.tid) {
12722 lib_fast::EncodeUnsigned(buf,parent.id,false);
12723 lib_fast::SetPmapBit(pmap,0);
12724 }
12725 tid_SetAssigned(state);
12726 state.tid = parent.id;
12727 // Value string none mandatory
12728 lib_fast::EncodeString(buf,parent.Value,false);
12729 lib_fast::InsertPmap(buf,index,pmap);
12730}
12731
12732// --- fasttest.StrNone..FastDecode
12733bool fasttest::StrNone_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrNone& parent) {
12734 bool ok = true;
12735 // Value string none mandatory
12736 if (ok) {
12737 ok = lib_fast::DecodeString(from,parent.Value,false);
12738 if (!ok) {
12739 state.error << "fasttest.StrNone.Value: bad String" << eol;
12740 }
12741 }
12742 (void)pmap;//only to avoid -Wunused-parameter
12743 return ok;
12744}
12745
12746// --- fasttest.StrNone..FixEncode
12747void fasttest::StrNone_FixEncode(cstring& buf, fasttest::StrNone& parent, char soh) {
12748 buf << "1=" << parent.Value << soh;
12749}
12750
12751// --- fasttest.StrNoneOpt.base.CopyOut
12752// Copy fields out of row
12753void fasttest::parent_CopyOut(fasttest::StrNoneOpt &row, fasttest::TemplateHeader &out) {
12754 // length: field value is computed
12755 // id: field value is computed
12756 (void)row;//only to avoid -Wunused-parameter
12757 (void)out;//only to avoid -Wunused-parameter
12758}
12759
12760// --- fasttest.StrNoneOpt.Value.ReadStrptrMaybe
12761inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::StrNoneOpt &parent, algo::strptr in_str) {
12762 bool retval = true;
12763 algo::Smallstr30 Value_tmp;
12764 retval = algo::Smallstr30_ReadStrptrMaybe(Value_tmp, in_str);
12765 if (retval) {
12766 Value_Set(parent, Value_tmp);
12767 }
12768 return retval;
12769}
12770
12771// --- fasttest.StrNoneOpt.pmask_bitcurs.Next
12772// proceed to next item
12773void fasttest::StrNoneOpt_pmask_bitcurs_Next(StrNoneOpt_pmask_bitcurs &curs) {
12774 ++curs.bit;
12775 int index = curs.bit / 32;
12776 int offset = curs.bit % 32;
12777 for (; index < curs.n_elems; ++index, offset = 0) {
12778 u64 rest = curs.elems[index] >> offset;
12779 if (rest) {
12780 offset += algo::u64_BitScanForward(rest);
12781 break;
12782 }
12783 }
12784 curs.bit = index * 32 + offset;
12785}
12786
12787// --- fasttest.StrNoneOpt..ReadFieldMaybe
12788bool fasttest::StrNoneOpt_ReadFieldMaybe(fasttest::StrNoneOpt& parent, algo::strptr field, algo::strptr strval) {
12789 bool retval = true;
12790 fasttest::FieldId field_id;
12791 (void)value_SetStrptrMaybe(field_id,field);
12792 switch(field_id) {
12793 case fasttest_FieldId_base: {
12794 retval = false;
12795 break;
12796 }
12797 case fasttest_FieldId_length: {
12798 retval = false;
12799 break;
12800 }
12801 case fasttest_FieldId_id: {
12802 retval = false;
12803 break;
12804 }
12805 case fasttest_FieldId_pmask: {
12806 retval = false;
12807 break;
12808 }
12809 case fasttest_FieldId_Value: {
12810 retval = Value_ReadStrptrMaybe(parent, strval);
12811 if (retval) {
12812 pmask_qSetBit(parent, 0);
12813 }
12814 break;
12815 }
12816 default: break;
12817 }
12818 if (!retval) {
12819 algo_lib::AppendErrtext("attr",field);
12820 }
12821 return retval;
12822}
12823
12824// --- fasttest.StrNoneOpt..ReadStrptrMaybe
12825// Read fields of fasttest::StrNoneOpt from an ascii string.
12826// The format of the string is an ssim Tuple
12827bool fasttest::StrNoneOpt_ReadStrptrMaybe(fasttest::StrNoneOpt &parent, algo::strptr in_str) {
12828 bool retval = true;
12829 retval = algo::StripTypeTag(in_str, "fasttest.StrNoneOpt");
12830 ind_beg(algo::Attr_curs, attr, in_str) {
12831 retval = retval && StrNoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
12832 }ind_end;
12833 return retval;
12834}
12835
12836// --- fasttest.StrNoneOpt..Print
12837// print string representation of ROW to string STR
12838// cfmt:fasttest.StrNoneOpt.String printfmt:Tuple
12839void fasttest::StrNoneOpt_Print(fasttest::StrNoneOpt& row, algo::cstring& str) {
12840 algo::tempstr temp;
12841 str << "fasttest.StrNoneOpt";
12842
12843 if (Value_PresentQ(row)) {
12844 algo::Smallstr30_Print(row.Value, temp);
12845 PrintAttrSpaceReset(str,"Value", temp);
12846 }
12847}
12848
12849// --- fasttest.StrNoneOpt..FastEncode
12850void fasttest::StrNoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::StrNoneOpt& parent) {
12851 int index = ary_N(buf);
12852 u64 pmap(0);
12853 if (!tid_AssignedQ(state) || parent.id != state.tid) {
12854 lib_fast::EncodeUnsigned(buf,parent.id,false);
12855 lib_fast::SetPmapBit(pmap,0);
12856 }
12857 tid_SetAssigned(state);
12858 state.tid = parent.id;
12859 // Value string none optional
12860 if (Value_PresentQ(parent)) {
12861 lib_fast::EncodeString(buf,parent.Value,true);
12862 } else {
12863 lib_fast::EncodeNull(buf);
12864 }
12865 lib_fast::InsertPmap(buf,index,pmap);
12866}
12867
12868// --- fasttest.StrNoneOpt..FastDecode
12869bool fasttest::StrNoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::StrNoneOpt& parent) {
12870 bool ok = true;
12871 // Value string none optional
12872 if (ok) {
12873 bool prs = !lib_fast::DecodeNull(from);
12874 if (prs) {
12875 ok = lib_fast::DecodeString(from,parent.Value,true);
12876 if (!ok) {
12877 state.error << "fasttest.StrNoneOpt.Value: bad String" << eol;
12878 }
12879 }
12880 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
12881 }
12882 (void)pmap;//only to avoid -Wunused-parameter
12883 return ok;
12884}
12885
12886// --- fasttest.StrNoneOpt..FixEncode
12887void fasttest::StrNoneOpt_FixEncode(cstring& buf, fasttest::StrNoneOpt& parent, char soh) {
12888 if (Value_PresentQ(parent)) {
12889 buf << "1=" << parent.Value << soh;
12890 }
12891}
12892
12893// --- fasttest.TemplateHeader.id.ToCstr
12894// Convert numeric value of field to one of predefined string constants.
12895// If string is found, return a static C string. Otherwise, return NULL.
12896const char* fasttest::id_ToCstr(const fasttest::TemplateHeader& parent) {
12897 const char *ret = NULL;
12898 switch(id_GetEnum(parent)) {
12899 case fasttest_TemplateHeader_id_fasttest_BVConst: ret = "fasttest.BVConst"; break;
12900 case fasttest_TemplateHeader_id_fasttest_BVConstOpt: ret = "fasttest.BVConstOpt"; break;
12901 case fasttest_TemplateHeader_id_fasttest_BVCopy: ret = "fasttest.BVCopy"; break;
12902 case fasttest_TemplateHeader_id_fasttest_BVCopyNull: ret = "fasttest.BVCopyNull"; break;
12903 case fasttest_TemplateHeader_id_fasttest_BVCopyOpt: ret = "fasttest.BVCopyOpt"; break;
12904 case fasttest_TemplateHeader_id_fasttest_BVDflt: ret = "fasttest.BVDflt"; break;
12905 case fasttest_TemplateHeader_id_fasttest_BVDfltNull: ret = "fasttest.BVDfltNull"; break;
12906 case fasttest_TemplateHeader_id_fasttest_BVDfltOpt: ret = "fasttest.BVDfltOpt"; break;
12907 case fasttest_TemplateHeader_id_fasttest_BVNone: ret = "fasttest.BVNone"; break;
12908 case fasttest_TemplateHeader_id_fasttest_BVNoneOpt: ret = "fasttest.BVNoneOpt"; break;
12909 case fasttest_TemplateHeader_id_fasttest_GroupSgmOpt: ret = "fasttest.GroupSgmOpt"; break;
12910 case fasttest_TemplateHeader_id_fasttest_GroupTrv: ret = "fasttest.GroupTrv"; break;
12911 case fasttest_TemplateHeader_id_fasttest_GroupTrvOpt: ret = "fasttest.GroupTrvOpt"; break;
12912 case fasttest_TemplateHeader_id_fasttest_I32Const: ret = "fasttest.I32Const"; break;
12913 case fasttest_TemplateHeader_id_fasttest_I32ConstOpt: ret = "fasttest.I32ConstOpt"; break;
12914 case fasttest_TemplateHeader_id_fasttest_I32Copy: ret = "fasttest.I32Copy"; break;
12915 case fasttest_TemplateHeader_id_fasttest_I32CopyNull: ret = "fasttest.I32CopyNull"; break;
12916 case fasttest_TemplateHeader_id_fasttest_I32CopyOpt: ret = "fasttest.I32CopyOpt"; break;
12917 case fasttest_TemplateHeader_id_fasttest_I32Delta: ret = "fasttest.I32Delta"; break;
12918 case fasttest_TemplateHeader_id_fasttest_I32DeltaImpl: ret = "fasttest.I32DeltaImpl"; break;
12919 case fasttest_TemplateHeader_id_fasttest_I32DeltaNull: ret = "fasttest.I32DeltaNull"; break;
12920 case fasttest_TemplateHeader_id_fasttest_I32DeltaOpt: ret = "fasttest.I32DeltaOpt"; break;
12921 case fasttest_TemplateHeader_id_fasttest_I32Dflt: ret = "fasttest.I32Dflt"; break;
12922 case fasttest_TemplateHeader_id_fasttest_I32DfltNull: ret = "fasttest.I32DfltNull"; break;
12923 case fasttest_TemplateHeader_id_fasttest_I32DfltOpt: ret = "fasttest.I32DfltOpt"; break;
12924 case fasttest_TemplateHeader_id_fasttest_I32Incr: ret = "fasttest.I32Incr"; break;
12925 case fasttest_TemplateHeader_id_fasttest_I32IncrNV: ret = "fasttest.I32IncrNV"; break;
12926 case fasttest_TemplateHeader_id_fasttest_I32IncrNull: ret = "fasttest.I32IncrNull"; break;
12927 case fasttest_TemplateHeader_id_fasttest_I32IncrOpt: ret = "fasttest.I32IncrOpt"; break;
12928 case fasttest_TemplateHeader_id_fasttest_I32None: ret = "fasttest.I32None"; break;
12929 case fasttest_TemplateHeader_id_fasttest_I32NoneOpt: ret = "fasttest.I32NoneOpt"; break;
12930 case fasttest_TemplateHeader_id_fasttest_MsgPmap: ret = "fasttest.MsgPmap"; break;
12931 case fasttest_TemplateHeader_id_fasttest_Reset: ret = "fasttest.Reset"; break;
12932 case fasttest_TemplateHeader_id_fasttest_SampleEnumConst: ret = "fasttest.SampleEnumConst"; break;
12933 case fasttest_TemplateHeader_id_fasttest_SampleEnumCopy: ret = "fasttest.SampleEnumCopy"; break;
12934 case fasttest_TemplateHeader_id_fasttest_SampleEnumDefault: ret = "fasttest.SampleEnumDefault"; break;
12935 case fasttest_TemplateHeader_id_fasttest_SampleSetConst: ret = "fasttest.SampleSetConst"; break;
12936 case fasttest_TemplateHeader_id_fasttest_SampleSetCopy: ret = "fasttest.SampleSetCopy"; break;
12937 case fasttest_TemplateHeader_id_fasttest_SampleSetDefault: ret = "fasttest.SampleSetDefault"; break;
12938 case fasttest_TemplateHeader_id_fasttest_SclConst: ret = "fasttest.SclConst"; break;
12939 case fasttest_TemplateHeader_id_fasttest_SclConstOpt: ret = "fasttest.SclConstOpt"; break;
12940 case fasttest_TemplateHeader_id_fasttest_SclCopy: ret = "fasttest.SclCopy"; break;
12941 case fasttest_TemplateHeader_id_fasttest_SclCopyNull: ret = "fasttest.SclCopyNull"; break;
12942 case fasttest_TemplateHeader_id_fasttest_SclCopyOpt: ret = "fasttest.SclCopyOpt"; break;
12943 case fasttest_TemplateHeader_id_fasttest_SclDelta: ret = "fasttest.SclDelta"; break;
12944 case fasttest_TemplateHeader_id_fasttest_SclDeltaImpl: ret = "fasttest.SclDeltaImpl"; break;
12945 case fasttest_TemplateHeader_id_fasttest_SclDeltaNull: ret = "fasttest.SclDeltaNull"; break;
12946 case fasttest_TemplateHeader_id_fasttest_SclDeltaOpt: ret = "fasttest.SclDeltaOpt"; break;
12947 case fasttest_TemplateHeader_id_fasttest_SclDflt: ret = "fasttest.SclDflt"; break;
12948 case fasttest_TemplateHeader_id_fasttest_SclDfltNull: ret = "fasttest.SclDfltNull"; break;
12949 case fasttest_TemplateHeader_id_fasttest_SclDfltOpt: ret = "fasttest.SclDfltOpt"; break;
12950 case fasttest_TemplateHeader_id_fasttest_SclNone: ret = "fasttest.SclNone"; break;
12951 case fasttest_TemplateHeader_id_fasttest_SclNoneOpt: ret = "fasttest.SclNoneOpt"; break;
12952 case fasttest_TemplateHeader_id_fasttest_SeqOrder: ret = "fasttest.SeqOrder"; break;
12953 case fasttest_TemplateHeader_id_fasttest_SeqSgmOpt: ret = "fasttest.SeqSgmOpt"; break;
12954 case fasttest_TemplateHeader_id_fasttest_SeqTrv: ret = "fasttest.SeqTrv"; break;
12955 case fasttest_TemplateHeader_id_fasttest_SeqTrvLenConst: ret = "fasttest.SeqTrvLenConst"; break;
12956 case fasttest_TemplateHeader_id_fasttest_SeqTrvLenConstOpt: ret = "fasttest.SeqTrvLenConstOpt"; break;
12957 case fasttest_TemplateHeader_id_fasttest_SeqTrvLenDflt: ret = "fasttest.SeqTrvLenDflt"; break;
12958 case fasttest_TemplateHeader_id_fasttest_SeqTrvLenDfltOpt: ret = "fasttest.SeqTrvLenDfltOpt"; break;
12959 case fasttest_TemplateHeader_id_fasttest_SeqTrvLenNone: ret = "fasttest.SeqTrvLenNone"; break;
12960 case fasttest_TemplateHeader_id_fasttest_SeqTrvLenNoneOpt: ret = "fasttest.SeqTrvLenNoneOpt"; break;
12961 case fasttest_TemplateHeader_id_fasttest_SeqTrvOpt: ret = "fasttest.SeqTrvOpt"; break;
12962 case fasttest_TemplateHeader_id_fasttest_StrConst: ret = "fasttest.StrConst"; break;
12963 case fasttest_TemplateHeader_id_fasttest_StrConstOpt: ret = "fasttest.StrConstOpt"; break;
12964 case fasttest_TemplateHeader_id_fasttest_StrCopy: ret = "fasttest.StrCopy"; break;
12965 case fasttest_TemplateHeader_id_fasttest_StrCopyNull: ret = "fasttest.StrCopyNull"; break;
12966 case fasttest_TemplateHeader_id_fasttest_StrCopyOpt: ret = "fasttest.StrCopyOpt"; break;
12967 case fasttest_TemplateHeader_id_fasttest_StrDflt: ret = "fasttest.StrDflt"; break;
12968 case fasttest_TemplateHeader_id_fasttest_StrDfltNull: ret = "fasttest.StrDfltNull"; break;
12969 case fasttest_TemplateHeader_id_fasttest_StrDfltOpt: ret = "fasttest.StrDfltOpt"; break;
12970 case fasttest_TemplateHeader_id_fasttest_StrNone: ret = "fasttest.StrNone"; break;
12971 case fasttest_TemplateHeader_id_fasttest_StrNoneOpt: ret = "fasttest.StrNoneOpt"; break;
12972 case fasttest_TemplateHeader_id_fasttest_U32Const: ret = "fasttest.U32Const"; break;
12973 case fasttest_TemplateHeader_id_fasttest_U32ConstOpt: ret = "fasttest.U32ConstOpt"; break;
12974 case fasttest_TemplateHeader_id_fasttest_U32Copy: ret = "fasttest.U32Copy"; break;
12975 case fasttest_TemplateHeader_id_fasttest_U32CopyNull: ret = "fasttest.U32CopyNull"; break;
12976 case fasttest_TemplateHeader_id_fasttest_U32CopyOpt: ret = "fasttest.U32CopyOpt"; break;
12977 case fasttest_TemplateHeader_id_fasttest_U32Delta: ret = "fasttest.U32Delta"; break;
12978 case fasttest_TemplateHeader_id_fasttest_U32DeltaImpl: ret = "fasttest.U32DeltaImpl"; break;
12979 case fasttest_TemplateHeader_id_fasttest_U32DeltaNull: ret = "fasttest.U32DeltaNull"; break;
12980 case fasttest_TemplateHeader_id_fasttest_U32DeltaOpt: ret = "fasttest.U32DeltaOpt"; break;
12981 case fasttest_TemplateHeader_id_fasttest_U32Dflt: ret = "fasttest.U32Dflt"; break;
12982 case fasttest_TemplateHeader_id_fasttest_U32DfltNull: ret = "fasttest.U32DfltNull"; break;
12983 case fasttest_TemplateHeader_id_fasttest_U32DfltOpt: ret = "fasttest.U32DfltOpt"; break;
12984 case fasttest_TemplateHeader_id_fasttest_U32Incr: ret = "fasttest.U32Incr"; break;
12985 case fasttest_TemplateHeader_id_fasttest_U32IncrNV: ret = "fasttest.U32IncrNV"; break;
12986 case fasttest_TemplateHeader_id_fasttest_U32IncrNull: ret = "fasttest.U32IncrNull"; break;
12987 case fasttest_TemplateHeader_id_fasttest_U32IncrOpt: ret = "fasttest.U32IncrOpt"; break;
12988 case fasttest_TemplateHeader_id_fasttest_U32None: ret = "fasttest.U32None"; break;
12989 case fasttest_TemplateHeader_id_fasttest_U32NoneOpt: ret = "fasttest.U32NoneOpt"; break;
12990 }
12991 return ret;
12992}
12993
12994// --- fasttest.TemplateHeader.id.Print
12995// Convert id to a string. First, attempt conversion to a known string.
12996// If no string matches, print id as a numeric value.
12997void fasttest::id_Print(const fasttest::TemplateHeader& parent, algo::cstring &lhs) {
12998 const char *strval = id_ToCstr(parent);
12999 if (strval) {
13000 lhs << strval;
13001 } else {
13002 lhs << parent.id;
13003 }
13004}
13005
13006// --- fasttest.TemplateHeader.id.SetStrptrMaybe
13007// Convert string to field.
13008// If the string is invalid, do not modify field and return false.
13009// In case of success, return true
13010bool fasttest::id_SetStrptrMaybe(fasttest::TemplateHeader& parent, algo::strptr rhs) {
13011 bool ret = false;
13012 switch (elems_N(rhs)) {
13013 case 14: {
13014 switch (algo::ReadLE64(rhs.elems)) {
13015 case LE_STR8('f','a','s','t','t','e','s','t'): {
13016 if (memcmp(rhs.elems+8,".Reset",6)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_Reset); ret = true; break; }
13017 break;
13018 }
13019 }
13020 break;
13021 }
13022 case 15: {
13023 switch (algo::ReadLE64(rhs.elems)) {
13024 case LE_STR8('f','a','s','t','t','e','s','t'): {
13025 if (memcmp(rhs.elems+8,".BVCopy",7)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVCopy); ret = true; break; }
13026 if (memcmp(rhs.elems+8,".BVDflt",7)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVDflt); ret = true; break; }
13027 if (memcmp(rhs.elems+8,".BVNone",7)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVNone); ret = true; break; }
13028 if (memcmp(rhs.elems+8,".SeqTrv",7)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrv); ret = true; break; }
13029 break;
13030 }
13031 }
13032 break;
13033 }
13034 case 16: {
13035 switch (algo::ReadLE64(rhs.elems)) {
13036 case LE_STR8('f','a','s','t','t','e','s','t'): {
13037 if (memcmp(rhs.elems+8,".BVConst",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVConst); ret = true; break; }
13038 if (memcmp(rhs.elems+8,".I32Copy",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32Copy); ret = true; break; }
13039 if (memcmp(rhs.elems+8,".I32Dflt",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32Dflt); ret = true; break; }
13040 if (memcmp(rhs.elems+8,".I32Incr",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32Incr); ret = true; break; }
13041 if (memcmp(rhs.elems+8,".I32None",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32None); ret = true; break; }
13042 if (memcmp(rhs.elems+8,".MsgPmap",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_MsgPmap); ret = true; break; }
13043 if (memcmp(rhs.elems+8,".SclCopy",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclCopy); ret = true; break; }
13044 if (memcmp(rhs.elems+8,".SclDflt",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDflt); ret = true; break; }
13045 if (memcmp(rhs.elems+8,".SclNone",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclNone); ret = true; break; }
13046 if (memcmp(rhs.elems+8,".StrCopy",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrCopy); ret = true; break; }
13047 if (memcmp(rhs.elems+8,".StrDflt",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrDflt); ret = true; break; }
13048 if (memcmp(rhs.elems+8,".StrNone",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrNone); ret = true; break; }
13049 if (memcmp(rhs.elems+8,".U32Copy",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32Copy); ret = true; break; }
13050 if (memcmp(rhs.elems+8,".U32Dflt",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32Dflt); ret = true; break; }
13051 if (memcmp(rhs.elems+8,".U32Incr",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32Incr); ret = true; break; }
13052 if (memcmp(rhs.elems+8,".U32None",8)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32None); ret = true; break; }
13053 break;
13054 }
13055 }
13056 break;
13057 }
13058 case 17: {
13059 switch (algo::ReadLE64(rhs.elems)) {
13060 case LE_STR8('f','a','s','t','t','e','s','t'): {
13061 if (memcmp(rhs.elems+8,".GroupTrv",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_GroupTrv); ret = true; break; }
13062 if (memcmp(rhs.elems+8,".I32Const",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32Const); ret = true; break; }
13063 if (memcmp(rhs.elems+8,".I32Delta",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32Delta); ret = true; break; }
13064 if (memcmp(rhs.elems+8,".SclConst",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclConst); ret = true; break; }
13065 if (memcmp(rhs.elems+8,".SclDelta",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDelta); ret = true; break; }
13066 if (memcmp(rhs.elems+8,".SeqOrder",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqOrder); ret = true; break; }
13067 if (memcmp(rhs.elems+8,".StrConst",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrConst); ret = true; break; }
13068 if (memcmp(rhs.elems+8,".U32Const",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32Const); ret = true; break; }
13069 if (memcmp(rhs.elems+8,".U32Delta",9)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32Delta); ret = true; break; }
13070 break;
13071 }
13072 }
13073 break;
13074 }
13075 case 18: {
13076 switch (algo::ReadLE64(rhs.elems)) {
13077 case LE_STR8('f','a','s','t','t','e','s','t'): {
13078 if (memcmp(rhs.elems+8,".BVCopyOpt",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVCopyOpt); ret = true; break; }
13079 if (memcmp(rhs.elems+8,".BVDfltOpt",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVDfltOpt); ret = true; break; }
13080 if (memcmp(rhs.elems+8,".BVNoneOpt",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVNoneOpt); ret = true; break; }
13081 if (memcmp(rhs.elems+8,".I32IncrNV",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32IncrNV); ret = true; break; }
13082 if (memcmp(rhs.elems+8,".SeqSgmOpt",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqSgmOpt); ret = true; break; }
13083 if (memcmp(rhs.elems+8,".SeqTrvOpt",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvOpt); ret = true; break; }
13084 if (memcmp(rhs.elems+8,".U32IncrNV",10)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32IncrNV); ret = true; break; }
13085 break;
13086 }
13087 }
13088 break;
13089 }
13090 case 19: {
13091 switch (algo::ReadLE64(rhs.elems)) {
13092 case LE_STR8('f','a','s','t','t','e','s','t'): {
13093 if (memcmp(rhs.elems+8,".BVConstOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVConstOpt); ret = true; break; }
13094 if (memcmp(rhs.elems+8,".BVCopyNull",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVCopyNull); ret = true; break; }
13095 if (memcmp(rhs.elems+8,".BVDfltNull",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_BVDfltNull); ret = true; break; }
13096 if (memcmp(rhs.elems+8,".I32CopyOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32CopyOpt); ret = true; break; }
13097 if (memcmp(rhs.elems+8,".I32DfltOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32DfltOpt); ret = true; break; }
13098 if (memcmp(rhs.elems+8,".I32IncrOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32IncrOpt); ret = true; break; }
13099 if (memcmp(rhs.elems+8,".I32NoneOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32NoneOpt); ret = true; break; }
13100 if (memcmp(rhs.elems+8,".SclCopyOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclCopyOpt); ret = true; break; }
13101 if (memcmp(rhs.elems+8,".SclDfltOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDfltOpt); ret = true; break; }
13102 if (memcmp(rhs.elems+8,".SclNoneOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclNoneOpt); ret = true; break; }
13103 if (memcmp(rhs.elems+8,".StrCopyOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrCopyOpt); ret = true; break; }
13104 if (memcmp(rhs.elems+8,".StrDfltOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrDfltOpt); ret = true; break; }
13105 if (memcmp(rhs.elems+8,".StrNoneOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrNoneOpt); ret = true; break; }
13106 if (memcmp(rhs.elems+8,".U32CopyOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32CopyOpt); ret = true; break; }
13107 if (memcmp(rhs.elems+8,".U32DfltOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32DfltOpt); ret = true; break; }
13108 if (memcmp(rhs.elems+8,".U32IncrOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32IncrOpt); ret = true; break; }
13109 if (memcmp(rhs.elems+8,".U32NoneOpt",11)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32NoneOpt); ret = true; break; }
13110 break;
13111 }
13112 }
13113 break;
13114 }
13115 case 20: {
13116 switch (algo::ReadLE64(rhs.elems)) {
13117 case LE_STR8('f','a','s','t','t','e','s','t'): {
13118 if (memcmp(rhs.elems+8,".GroupSgmOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_GroupSgmOpt); ret = true; break; }
13119 if (memcmp(rhs.elems+8,".GroupTrvOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_GroupTrvOpt); ret = true; break; }
13120 if (memcmp(rhs.elems+8,".I32ConstOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32ConstOpt); ret = true; break; }
13121 if (memcmp(rhs.elems+8,".I32CopyNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32CopyNull); ret = true; break; }
13122 if (memcmp(rhs.elems+8,".I32DeltaOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32DeltaOpt); ret = true; break; }
13123 if (memcmp(rhs.elems+8,".I32DfltNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32DfltNull); ret = true; break; }
13124 if (memcmp(rhs.elems+8,".I32IncrNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32IncrNull); ret = true; break; }
13125 if (memcmp(rhs.elems+8,".SclConstOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclConstOpt); ret = true; break; }
13126 if (memcmp(rhs.elems+8,".SclCopyNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclCopyNull); ret = true; break; }
13127 if (memcmp(rhs.elems+8,".SclDeltaOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDeltaOpt); ret = true; break; }
13128 if (memcmp(rhs.elems+8,".SclDfltNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDfltNull); ret = true; break; }
13129 if (memcmp(rhs.elems+8,".StrConstOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrConstOpt); ret = true; break; }
13130 if (memcmp(rhs.elems+8,".StrCopyNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrCopyNull); ret = true; break; }
13131 if (memcmp(rhs.elems+8,".StrDfltNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_StrDfltNull); ret = true; break; }
13132 if (memcmp(rhs.elems+8,".U32ConstOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32ConstOpt); ret = true; break; }
13133 if (memcmp(rhs.elems+8,".U32CopyNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32CopyNull); ret = true; break; }
13134 if (memcmp(rhs.elems+8,".U32DeltaOpt",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32DeltaOpt); ret = true; break; }
13135 if (memcmp(rhs.elems+8,".U32DfltNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32DfltNull); ret = true; break; }
13136 if (memcmp(rhs.elems+8,".U32IncrNull",12)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32IncrNull); ret = true; break; }
13137 break;
13138 }
13139 }
13140 break;
13141 }
13142 case 21: {
13143 switch (algo::ReadLE64(rhs.elems)) {
13144 case LE_STR8('f','a','s','t','t','e','s','t'): {
13145 if (memcmp(rhs.elems+8,".I32DeltaImpl",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32DeltaImpl); ret = true; break; }
13146 if (memcmp(rhs.elems+8,".I32DeltaNull",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_I32DeltaNull); ret = true; break; }
13147 if (memcmp(rhs.elems+8,".SclDeltaImpl",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDeltaImpl); ret = true; break; }
13148 if (memcmp(rhs.elems+8,".SclDeltaNull",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SclDeltaNull); ret = true; break; }
13149 if (memcmp(rhs.elems+8,".U32DeltaImpl",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32DeltaImpl); ret = true; break; }
13150 if (memcmp(rhs.elems+8,".U32DeltaNull",13)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_U32DeltaNull); ret = true; break; }
13151 break;
13152 }
13153 }
13154 break;
13155 }
13156 case 22: {
13157 switch (algo::ReadLE64(rhs.elems)) {
13158 case LE_STR8('f','a','s','t','t','e','s','t'): {
13159 if (memcmp(rhs.elems+8,".SampleSetCopy",14)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleSetCopy); ret = true; break; }
13160 if (memcmp(rhs.elems+8,".SeqTrvLenDflt",14)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenDflt); ret = true; break; }
13161 if (memcmp(rhs.elems+8,".SeqTrvLenNone",14)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenNone); ret = true; break; }
13162 break;
13163 }
13164 }
13165 break;
13166 }
13167 case 23: {
13168 switch (algo::ReadLE64(rhs.elems)) {
13169 case LE_STR8('f','a','s','t','t','e','s','t'): {
13170 if (memcmp(rhs.elems+8,".SampleEnumCopy",15)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleEnumCopy); ret = true; break; }
13171 if (memcmp(rhs.elems+8,".SampleSetConst",15)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleSetConst); ret = true; break; }
13172 if (memcmp(rhs.elems+8,".SeqTrvLenConst",15)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenConst); ret = true; break; }
13173 break;
13174 }
13175 }
13176 break;
13177 }
13178 case 24: {
13179 switch (algo::ReadLE64(rhs.elems)) {
13180 case LE_STR8('f','a','s','t','t','e','s','t'): {
13181 if (memcmp(rhs.elems+8,".SampleEnumConst",16)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleEnumConst); ret = true; break; }
13182 break;
13183 }
13184 }
13185 break;
13186 }
13187 case 25: {
13188 switch (algo::ReadLE64(rhs.elems)) {
13189 case LE_STR8('f','a','s','t','t','e','s','t'): {
13190 if (memcmp(rhs.elems+8,".SampleSetDefault",17)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleSetDefault); ret = true; break; }
13191 if (memcmp(rhs.elems+8,".SeqTrvLenDfltOpt",17)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenDfltOpt); ret = true; break; }
13192 if (memcmp(rhs.elems+8,".SeqTrvLenNoneOpt",17)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenNoneOpt); ret = true; break; }
13193 break;
13194 }
13195 }
13196 break;
13197 }
13198 case 26: {
13199 switch (algo::ReadLE64(rhs.elems)) {
13200 case LE_STR8('f','a','s','t','t','e','s','t'): {
13201 if (memcmp(rhs.elems+8,".SampleEnumDefault",18)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SampleEnumDefault); ret = true; break; }
13202 if (memcmp(rhs.elems+8,".SeqTrvLenConstOpt",18)==0) { id_SetEnum(parent,fasttest_TemplateHeader_id_fasttest_SeqTrvLenConstOpt); ret = true; break; }
13203 break;
13204 }
13205 }
13206 break;
13207 }
13208 }
13209 return ret;
13210}
13211
13212// --- fasttest.TemplateHeader.id.SetStrptr
13213// Convert string to field.
13214// If the string is invalid, set numeric value to DFLT
13215void fasttest::id_SetStrptr(fasttest::TemplateHeader& parent, algo::strptr rhs, fasttest_TemplateHeader_id_Enum dflt) {
13216 if (!id_SetStrptrMaybe(parent,rhs)) id_SetEnum(parent,dflt);
13217}
13218
13219// --- fasttest.TemplateHeader.id.ReadStrptrMaybe
13220// Convert string to field. Return success value
13221bool fasttest::id_ReadStrptrMaybe(fasttest::TemplateHeader& parent, algo::strptr rhs) {
13222 bool retval = false;
13223 retval = id_SetStrptrMaybe(parent,rhs); // try symbol conversion
13224 if (!retval) { // didn't work? try reading as underlying type
13225 retval = u32_ReadStrptrMaybe(parent.id,rhs);
13226 }
13227 return retval;
13228}
13229
13230// --- fasttest.TemplateHeader..ReadFieldMaybe
13231bool fasttest::TemplateHeader_ReadFieldMaybe(fasttest::TemplateHeader& parent, algo::strptr field, algo::strptr strval) {
13232 bool retval = true;
13233 fasttest::FieldId field_id;
13234 (void)value_SetStrptrMaybe(field_id,field);
13235 switch(field_id) {
13236 case fasttest_FieldId_length: {
13237 retval = false;
13238 break;
13239 }
13240 case fasttest_FieldId_id: {
13241 retval = id_ReadStrptrMaybe(parent, strval);
13242 break;
13243 }
13244 default: break;
13245 }
13246 if (!retval) {
13247 algo_lib::AppendErrtext("attr",field);
13248 }
13249 return retval;
13250}
13251
13252// --- fasttest.TemplateHeader..ReadStrptrMaybe
13253// Read fields of fasttest::TemplateHeader from an ascii string.
13254// The format of the string is an ssim Tuple
13255bool fasttest::TemplateHeader_ReadStrptrMaybe(fasttest::TemplateHeader &parent, algo::strptr in_str) {
13256 bool retval = true;
13257 retval = algo::StripTypeTag(in_str, "fasttest.TemplateHeader");
13258 ind_beg(algo::Attr_curs, attr, in_str) {
13259 retval = retval && TemplateHeader_ReadFieldMaybe(parent, attr.name, attr.value);
13260 }ind_end;
13261 return retval;
13262}
13263
13264// --- fasttest.TemplateHeader..Print
13265// print string representation of ROW to string STR
13266// cfmt:fasttest.TemplateHeader.String printfmt:Tuple
13267void fasttest::TemplateHeader_Print(fasttest::TemplateHeader& row, algo::cstring& str) {
13268 algo::tempstr temp;
13269 str << "fasttest.TemplateHeader";
13270 (void)row;//only to avoid -Wunused-parameter
13271}
13272
13273// --- fasttest.TemplateHeaderMsgsCase.value.ToCstr
13274// Convert numeric value of field to one of predefined string constants.
13275// If string is found, return a static C string. Otherwise, return NULL.
13276const char* fasttest::value_ToCstr(const fasttest::TemplateHeaderMsgsCase& parent) {
13277 const char *ret = NULL;
13278 switch(value_GetEnum(parent)) {
13279 case fasttest_TemplateHeaderMsgsCase_fasttest_BVConst: ret = "fasttest.BVConst"; break;
13280 case fasttest_TemplateHeaderMsgsCase_fasttest_BVConstOpt: ret = "fasttest.BVConstOpt"; break;
13281 case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopy: ret = "fasttest.BVCopy"; break;
13282 case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyNull: ret = "fasttest.BVCopyNull"; break;
13283 case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyOpt: ret = "fasttest.BVCopyOpt"; break;
13284 case fasttest_TemplateHeaderMsgsCase_fasttest_BVDflt: ret = "fasttest.BVDflt"; break;
13285 case fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltNull: ret = "fasttest.BVDfltNull"; break;
13286 case fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltOpt: ret = "fasttest.BVDfltOpt"; break;
13287 case fasttest_TemplateHeaderMsgsCase_fasttest_BVNone: ret = "fasttest.BVNone"; break;
13288 case fasttest_TemplateHeaderMsgsCase_fasttest_BVNoneOpt: ret = "fasttest.BVNoneOpt"; break;
13289 case fasttest_TemplateHeaderMsgsCase_fasttest_GroupSgmOpt: ret = "fasttest.GroupSgmOpt"; break;
13290 case fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrv: ret = "fasttest.GroupTrv"; break;
13291 case fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrvOpt: ret = "fasttest.GroupTrvOpt"; break;
13292 case fasttest_TemplateHeaderMsgsCase_fasttest_I32Const: ret = "fasttest.I32Const"; break;
13293 case fasttest_TemplateHeaderMsgsCase_fasttest_I32ConstOpt: ret = "fasttest.I32ConstOpt"; break;
13294 case fasttest_TemplateHeaderMsgsCase_fasttest_I32Copy: ret = "fasttest.I32Copy"; break;
13295 case fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyNull: ret = "fasttest.I32CopyNull"; break;
13296 case fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyOpt: ret = "fasttest.I32CopyOpt"; break;
13297 case fasttest_TemplateHeaderMsgsCase_fasttest_I32Delta: ret = "fasttest.I32Delta"; break;
13298 case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaImpl: ret = "fasttest.I32DeltaImpl"; break;
13299 case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaNull: ret = "fasttest.I32DeltaNull"; break;
13300 case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaOpt: ret = "fasttest.I32DeltaOpt"; break;
13301 case fasttest_TemplateHeaderMsgsCase_fasttest_I32Dflt: ret = "fasttest.I32Dflt"; break;
13302 case fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltNull: ret = "fasttest.I32DfltNull"; break;
13303 case fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltOpt: ret = "fasttest.I32DfltOpt"; break;
13304 case fasttest_TemplateHeaderMsgsCase_fasttest_I32Incr: ret = "fasttest.I32Incr"; break;
13305 case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNV: ret = "fasttest.I32IncrNV"; break;
13306 case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNull: ret = "fasttest.I32IncrNull"; break;
13307 case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrOpt: ret = "fasttest.I32IncrOpt"; break;
13308 case fasttest_TemplateHeaderMsgsCase_fasttest_I32None: ret = "fasttest.I32None"; break;
13309 case fasttest_TemplateHeaderMsgsCase_fasttest_I32NoneOpt: ret = "fasttest.I32NoneOpt"; break;
13310 case fasttest_TemplateHeaderMsgsCase_fasttest_MsgPmap: ret = "fasttest.MsgPmap"; break;
13311 case fasttest_TemplateHeaderMsgsCase_fasttest_Reset: ret = "fasttest.Reset"; break;
13312 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumConst: ret = "fasttest.SampleEnumConst"; break;
13313 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumCopy: ret = "fasttest.SampleEnumCopy"; break;
13314 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumDefault: ret = "fasttest.SampleEnumDefault"; break;
13315 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetConst: ret = "fasttest.SampleSetConst"; break;
13316 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetCopy: ret = "fasttest.SampleSetCopy"; break;
13317 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetDefault: ret = "fasttest.SampleSetDefault"; break;
13318 case fasttest_TemplateHeaderMsgsCase_fasttest_SclConst: ret = "fasttest.SclConst"; break;
13319 case fasttest_TemplateHeaderMsgsCase_fasttest_SclConstOpt: ret = "fasttest.SclConstOpt"; break;
13320 case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopy: ret = "fasttest.SclCopy"; break;
13321 case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyNull: ret = "fasttest.SclCopyNull"; break;
13322 case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyOpt: ret = "fasttest.SclCopyOpt"; break;
13323 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDelta: ret = "fasttest.SclDelta"; break;
13324 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaImpl: ret = "fasttest.SclDeltaImpl"; break;
13325 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaNull: ret = "fasttest.SclDeltaNull"; break;
13326 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaOpt: ret = "fasttest.SclDeltaOpt"; break;
13327 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDflt: ret = "fasttest.SclDflt"; break;
13328 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltNull: ret = "fasttest.SclDfltNull"; break;
13329 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltOpt: ret = "fasttest.SclDfltOpt"; break;
13330 case fasttest_TemplateHeaderMsgsCase_fasttest_SclNone: ret = "fasttest.SclNone"; break;
13331 case fasttest_TemplateHeaderMsgsCase_fasttest_SclNoneOpt: ret = "fasttest.SclNoneOpt"; break;
13332 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqOrder: ret = "fasttest.SeqOrder"; break;
13333 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqSgmOpt: ret = "fasttest.SeqSgmOpt"; break;
13334 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrv: ret = "fasttest.SeqTrv"; break;
13335 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConst: ret = "fasttest.SeqTrvLenConst"; break;
13336 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConstOpt: ret = "fasttest.SeqTrvLenConstOpt"; break;
13337 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDflt: ret = "fasttest.SeqTrvLenDflt"; break;
13338 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDfltOpt: ret = "fasttest.SeqTrvLenDfltOpt"; break;
13339 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNone: ret = "fasttest.SeqTrvLenNone"; break;
13340 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNoneOpt: ret = "fasttest.SeqTrvLenNoneOpt"; break;
13341 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvOpt: ret = "fasttest.SeqTrvOpt"; break;
13342 case fasttest_TemplateHeaderMsgsCase_fasttest_StrConst: ret = "fasttest.StrConst"; break;
13343 case fasttest_TemplateHeaderMsgsCase_fasttest_StrConstOpt: ret = "fasttest.StrConstOpt"; break;
13344 case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopy: ret = "fasttest.StrCopy"; break;
13345 case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyNull: ret = "fasttest.StrCopyNull"; break;
13346 case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyOpt: ret = "fasttest.StrCopyOpt"; break;
13347 case fasttest_TemplateHeaderMsgsCase_fasttest_StrDflt: ret = "fasttest.StrDflt"; break;
13348 case fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltNull: ret = "fasttest.StrDfltNull"; break;
13349 case fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltOpt: ret = "fasttest.StrDfltOpt"; break;
13350 case fasttest_TemplateHeaderMsgsCase_fasttest_StrNone: ret = "fasttest.StrNone"; break;
13351 case fasttest_TemplateHeaderMsgsCase_fasttest_StrNoneOpt: ret = "fasttest.StrNoneOpt"; break;
13352 case fasttest_TemplateHeaderMsgsCase_fasttest_U32Const: ret = "fasttest.U32Const"; break;
13353 case fasttest_TemplateHeaderMsgsCase_fasttest_U32ConstOpt: ret = "fasttest.U32ConstOpt"; break;
13354 case fasttest_TemplateHeaderMsgsCase_fasttest_U32Copy: ret = "fasttest.U32Copy"; break;
13355 case fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyNull: ret = "fasttest.U32CopyNull"; break;
13356 case fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyOpt: ret = "fasttest.U32CopyOpt"; break;
13357 case fasttest_TemplateHeaderMsgsCase_fasttest_U32Delta: ret = "fasttest.U32Delta"; break;
13358 case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaImpl: ret = "fasttest.U32DeltaImpl"; break;
13359 case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaNull: ret = "fasttest.U32DeltaNull"; break;
13360 case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaOpt: ret = "fasttest.U32DeltaOpt"; break;
13361 case fasttest_TemplateHeaderMsgsCase_fasttest_U32Dflt: ret = "fasttest.U32Dflt"; break;
13362 case fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltNull: ret = "fasttest.U32DfltNull"; break;
13363 case fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltOpt: ret = "fasttest.U32DfltOpt"; break;
13364 case fasttest_TemplateHeaderMsgsCase_fasttest_U32Incr: ret = "fasttest.U32Incr"; break;
13365 case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNV: ret = "fasttest.U32IncrNV"; break;
13366 case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNull: ret = "fasttest.U32IncrNull"; break;
13367 case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrOpt: ret = "fasttest.U32IncrOpt"; break;
13368 case fasttest_TemplateHeaderMsgsCase_fasttest_U32None: ret = "fasttest.U32None"; break;
13369 case fasttest_TemplateHeaderMsgsCase_fasttest_U32NoneOpt: ret = "fasttest.U32NoneOpt"; break;
13370 }
13371 return ret;
13372}
13373
13374// --- fasttest.TemplateHeaderMsgsCase.value.Print
13375// Convert value to a string. First, attempt conversion to a known string.
13376// If no string matches, print value as a numeric value.
13377void fasttest::value_Print(const fasttest::TemplateHeaderMsgsCase& parent, algo::cstring &lhs) {
13378 const char *strval = value_ToCstr(parent);
13379 if (strval) {
13380 lhs << strval;
13381 } else {
13382 lhs << parent.value;
13383 }
13384}
13385
13386// --- fasttest.TemplateHeaderMsgsCase.value.SetStrptrMaybe
13387// Convert string to field.
13388// If the string is invalid, do not modify field and return false.
13389// In case of success, return true
13390bool fasttest::value_SetStrptrMaybe(fasttest::TemplateHeaderMsgsCase& parent, algo::strptr rhs) {
13391 bool ret = false;
13392 switch (elems_N(rhs)) {
13393 case 14: {
13394 switch (algo::ReadLE64(rhs.elems)) {
13395 case LE_STR8('f','a','s','t','t','e','s','t'): {
13396 if (memcmp(rhs.elems+8,".Reset",6)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_Reset); ret = true; break; }
13397 break;
13398 }
13399 }
13400 break;
13401 }
13402 case 15: {
13403 switch (algo::ReadLE64(rhs.elems)) {
13404 case LE_STR8('f','a','s','t','t','e','s','t'): {
13405 if (memcmp(rhs.elems+8,".BVCopy",7)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVCopy); ret = true; break; }
13406 if (memcmp(rhs.elems+8,".BVDflt",7)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVDflt); ret = true; break; }
13407 if (memcmp(rhs.elems+8,".BVNone",7)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVNone); ret = true; break; }
13408 if (memcmp(rhs.elems+8,".SeqTrv",7)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrv); ret = true; break; }
13409 break;
13410 }
13411 }
13412 break;
13413 }
13414 case 16: {
13415 switch (algo::ReadLE64(rhs.elems)) {
13416 case LE_STR8('f','a','s','t','t','e','s','t'): {
13417 if (memcmp(rhs.elems+8,".BVConst",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVConst); ret = true; break; }
13418 if (memcmp(rhs.elems+8,".I32Copy",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32Copy); ret = true; break; }
13419 if (memcmp(rhs.elems+8,".I32Dflt",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32Dflt); ret = true; break; }
13420 if (memcmp(rhs.elems+8,".I32Incr",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32Incr); ret = true; break; }
13421 if (memcmp(rhs.elems+8,".I32None",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32None); ret = true; break; }
13422 if (memcmp(rhs.elems+8,".MsgPmap",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_MsgPmap); ret = true; break; }
13423 if (memcmp(rhs.elems+8,".SclCopy",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclCopy); ret = true; break; }
13424 if (memcmp(rhs.elems+8,".SclDflt",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDflt); ret = true; break; }
13425 if (memcmp(rhs.elems+8,".SclNone",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclNone); ret = true; break; }
13426 if (memcmp(rhs.elems+8,".StrCopy",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrCopy); ret = true; break; }
13427 if (memcmp(rhs.elems+8,".StrDflt",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrDflt); ret = true; break; }
13428 if (memcmp(rhs.elems+8,".StrNone",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrNone); ret = true; break; }
13429 if (memcmp(rhs.elems+8,".U32Copy",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32Copy); ret = true; break; }
13430 if (memcmp(rhs.elems+8,".U32Dflt",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32Dflt); ret = true; break; }
13431 if (memcmp(rhs.elems+8,".U32Incr",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32Incr); ret = true; break; }
13432 if (memcmp(rhs.elems+8,".U32None",8)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32None); ret = true; break; }
13433 break;
13434 }
13435 }
13436 break;
13437 }
13438 case 17: {
13439 switch (algo::ReadLE64(rhs.elems)) {
13440 case LE_STR8('f','a','s','t','t','e','s','t'): {
13441 if (memcmp(rhs.elems+8,".GroupTrv",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrv); ret = true; break; }
13442 if (memcmp(rhs.elems+8,".I32Const",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32Const); ret = true; break; }
13443 if (memcmp(rhs.elems+8,".I32Delta",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32Delta); ret = true; break; }
13444 if (memcmp(rhs.elems+8,".SclConst",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclConst); ret = true; break; }
13445 if (memcmp(rhs.elems+8,".SclDelta",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDelta); ret = true; break; }
13446 if (memcmp(rhs.elems+8,".SeqOrder",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqOrder); ret = true; break; }
13447 if (memcmp(rhs.elems+8,".StrConst",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrConst); ret = true; break; }
13448 if (memcmp(rhs.elems+8,".U32Const",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32Const); ret = true; break; }
13449 if (memcmp(rhs.elems+8,".U32Delta",9)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32Delta); ret = true; break; }
13450 break;
13451 }
13452 }
13453 break;
13454 }
13455 case 18: {
13456 switch (algo::ReadLE64(rhs.elems)) {
13457 case LE_STR8('f','a','s','t','t','e','s','t'): {
13458 if (memcmp(rhs.elems+8,".BVCopyOpt",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyOpt); ret = true; break; }
13459 if (memcmp(rhs.elems+8,".BVDfltOpt",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltOpt); ret = true; break; }
13460 if (memcmp(rhs.elems+8,".BVNoneOpt",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVNoneOpt); ret = true; break; }
13461 if (memcmp(rhs.elems+8,".I32IncrNV",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNV); ret = true; break; }
13462 if (memcmp(rhs.elems+8,".SeqSgmOpt",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqSgmOpt); ret = true; break; }
13463 if (memcmp(rhs.elems+8,".SeqTrvOpt",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvOpt); ret = true; break; }
13464 if (memcmp(rhs.elems+8,".U32IncrNV",10)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNV); ret = true; break; }
13465 break;
13466 }
13467 }
13468 break;
13469 }
13470 case 19: {
13471 switch (algo::ReadLE64(rhs.elems)) {
13472 case LE_STR8('f','a','s','t','t','e','s','t'): {
13473 if (memcmp(rhs.elems+8,".BVConstOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVConstOpt); ret = true; break; }
13474 if (memcmp(rhs.elems+8,".BVCopyNull",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyNull); ret = true; break; }
13475 if (memcmp(rhs.elems+8,".BVDfltNull",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltNull); ret = true; break; }
13476 if (memcmp(rhs.elems+8,".I32CopyOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyOpt); ret = true; break; }
13477 if (memcmp(rhs.elems+8,".I32DfltOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltOpt); ret = true; break; }
13478 if (memcmp(rhs.elems+8,".I32IncrOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrOpt); ret = true; break; }
13479 if (memcmp(rhs.elems+8,".I32NoneOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32NoneOpt); ret = true; break; }
13480 if (memcmp(rhs.elems+8,".SclCopyOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyOpt); ret = true; break; }
13481 if (memcmp(rhs.elems+8,".SclDfltOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltOpt); ret = true; break; }
13482 if (memcmp(rhs.elems+8,".SclNoneOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclNoneOpt); ret = true; break; }
13483 if (memcmp(rhs.elems+8,".StrCopyOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyOpt); ret = true; break; }
13484 if (memcmp(rhs.elems+8,".StrDfltOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltOpt); ret = true; break; }
13485 if (memcmp(rhs.elems+8,".StrNoneOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrNoneOpt); ret = true; break; }
13486 if (memcmp(rhs.elems+8,".U32CopyOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyOpt); ret = true; break; }
13487 if (memcmp(rhs.elems+8,".U32DfltOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltOpt); ret = true; break; }
13488 if (memcmp(rhs.elems+8,".U32IncrOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrOpt); ret = true; break; }
13489 if (memcmp(rhs.elems+8,".U32NoneOpt",11)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32NoneOpt); ret = true; break; }
13490 break;
13491 }
13492 }
13493 break;
13494 }
13495 case 20: {
13496 switch (algo::ReadLE64(rhs.elems)) {
13497 case LE_STR8('f','a','s','t','t','e','s','t'): {
13498 if (memcmp(rhs.elems+8,".GroupSgmOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_GroupSgmOpt); ret = true; break; }
13499 if (memcmp(rhs.elems+8,".GroupTrvOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrvOpt); ret = true; break; }
13500 if (memcmp(rhs.elems+8,".I32ConstOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32ConstOpt); ret = true; break; }
13501 if (memcmp(rhs.elems+8,".I32CopyNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyNull); ret = true; break; }
13502 if (memcmp(rhs.elems+8,".I32DeltaOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaOpt); ret = true; break; }
13503 if (memcmp(rhs.elems+8,".I32DfltNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltNull); ret = true; break; }
13504 if (memcmp(rhs.elems+8,".I32IncrNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNull); ret = true; break; }
13505 if (memcmp(rhs.elems+8,".SclConstOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclConstOpt); ret = true; break; }
13506 if (memcmp(rhs.elems+8,".SclCopyNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyNull); ret = true; break; }
13507 if (memcmp(rhs.elems+8,".SclDeltaOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaOpt); ret = true; break; }
13508 if (memcmp(rhs.elems+8,".SclDfltNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltNull); ret = true; break; }
13509 if (memcmp(rhs.elems+8,".StrConstOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrConstOpt); ret = true; break; }
13510 if (memcmp(rhs.elems+8,".StrCopyNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyNull); ret = true; break; }
13511 if (memcmp(rhs.elems+8,".StrDfltNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltNull); ret = true; break; }
13512 if (memcmp(rhs.elems+8,".U32ConstOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32ConstOpt); ret = true; break; }
13513 if (memcmp(rhs.elems+8,".U32CopyNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyNull); ret = true; break; }
13514 if (memcmp(rhs.elems+8,".U32DeltaOpt",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaOpt); ret = true; break; }
13515 if (memcmp(rhs.elems+8,".U32DfltNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltNull); ret = true; break; }
13516 if (memcmp(rhs.elems+8,".U32IncrNull",12)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNull); ret = true; break; }
13517 break;
13518 }
13519 }
13520 break;
13521 }
13522 case 21: {
13523 switch (algo::ReadLE64(rhs.elems)) {
13524 case LE_STR8('f','a','s','t','t','e','s','t'): {
13525 if (memcmp(rhs.elems+8,".I32DeltaImpl",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaImpl); ret = true; break; }
13526 if (memcmp(rhs.elems+8,".I32DeltaNull",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaNull); ret = true; break; }
13527 if (memcmp(rhs.elems+8,".SclDeltaImpl",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaImpl); ret = true; break; }
13528 if (memcmp(rhs.elems+8,".SclDeltaNull",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaNull); ret = true; break; }
13529 if (memcmp(rhs.elems+8,".U32DeltaImpl",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaImpl); ret = true; break; }
13530 if (memcmp(rhs.elems+8,".U32DeltaNull",13)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaNull); ret = true; break; }
13531 break;
13532 }
13533 }
13534 break;
13535 }
13536 case 22: {
13537 switch (algo::ReadLE64(rhs.elems)) {
13538 case LE_STR8('f','a','s','t','t','e','s','t'): {
13539 if (memcmp(rhs.elems+8,".SampleSetCopy",14)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetCopy); ret = true; break; }
13540 if (memcmp(rhs.elems+8,".SeqTrvLenDflt",14)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDflt); ret = true; break; }
13541 if (memcmp(rhs.elems+8,".SeqTrvLenNone",14)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNone); ret = true; break; }
13542 break;
13543 }
13544 }
13545 break;
13546 }
13547 case 23: {
13548 switch (algo::ReadLE64(rhs.elems)) {
13549 case LE_STR8('f','a','s','t','t','e','s','t'): {
13550 if (memcmp(rhs.elems+8,".SampleEnumCopy",15)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumCopy); ret = true; break; }
13551 if (memcmp(rhs.elems+8,".SampleSetConst",15)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetConst); ret = true; break; }
13552 if (memcmp(rhs.elems+8,".SeqTrvLenConst",15)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConst); ret = true; break; }
13553 break;
13554 }
13555 }
13556 break;
13557 }
13558 case 24: {
13559 switch (algo::ReadLE64(rhs.elems)) {
13560 case LE_STR8('f','a','s','t','t','e','s','t'): {
13561 if (memcmp(rhs.elems+8,".SampleEnumConst",16)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumConst); ret = true; break; }
13562 break;
13563 }
13564 }
13565 break;
13566 }
13567 case 25: {
13568 switch (algo::ReadLE64(rhs.elems)) {
13569 case LE_STR8('f','a','s','t','t','e','s','t'): {
13570 if (memcmp(rhs.elems+8,".SampleSetDefault",17)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetDefault); ret = true; break; }
13571 if (memcmp(rhs.elems+8,".SeqTrvLenDfltOpt",17)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDfltOpt); ret = true; break; }
13572 if (memcmp(rhs.elems+8,".SeqTrvLenNoneOpt",17)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNoneOpt); ret = true; break; }
13573 break;
13574 }
13575 }
13576 break;
13577 }
13578 case 26: {
13579 switch (algo::ReadLE64(rhs.elems)) {
13580 case LE_STR8('f','a','s','t','t','e','s','t'): {
13581 if (memcmp(rhs.elems+8,".SampleEnumDefault",18)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumDefault); ret = true; break; }
13582 if (memcmp(rhs.elems+8,".SeqTrvLenConstOpt",18)==0) { value_SetEnum(parent,fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConstOpt); ret = true; break; }
13583 break;
13584 }
13585 }
13586 break;
13587 }
13588 }
13589 return ret;
13590}
13591
13592// --- fasttest.TemplateHeaderMsgsCase.value.SetStrptr
13593// Convert string to field.
13594// If the string is invalid, set numeric value to DFLT
13595void fasttest::value_SetStrptr(fasttest::TemplateHeaderMsgsCase& parent, algo::strptr rhs, fasttest_TemplateHeaderMsgsCaseEnum dflt) {
13596 if (!value_SetStrptrMaybe(parent,rhs)) value_SetEnum(parent,dflt);
13597}
13598
13599// --- fasttest.TemplateHeaderMsgsCase.value.ReadStrptrMaybe
13600// Convert string to field. Return success value
13601bool fasttest::value_ReadStrptrMaybe(fasttest::TemplateHeaderMsgsCase& parent, algo::strptr rhs) {
13602 bool retval = false;
13603 retval = value_SetStrptrMaybe(parent,rhs); // try symbol conversion
13604 if (!retval) { // didn't work? try reading as underlying type
13605 retval = u32_ReadStrptrMaybe(parent.value,rhs);
13606 }
13607 return retval;
13608}
13609
13610// --- fasttest.TemplateHeaderMsgsCase..ReadStrptrMaybe
13611// Read fields of fasttest::TemplateHeaderMsgsCase from an ascii string.
13612// The format of the string is the format of the fasttest::TemplateHeaderMsgsCase's only field
13613bool fasttest::TemplateHeaderMsgsCase_ReadStrptrMaybe(fasttest::TemplateHeaderMsgsCase &parent, algo::strptr in_str) {
13614 bool retval = true;
13615 retval = retval && value_ReadStrptrMaybe(parent, in_str);
13616 return retval;
13617}
13618
13619// --- fasttest.U32Const.base.CopyOut
13620// Copy fields out of row
13621void fasttest::parent_CopyOut(fasttest::U32Const &row, fasttest::TemplateHeader &out) {
13622 // length: field value is computed
13623 // id: field value is computed
13624 (void)row;//only to avoid -Wunused-parameter
13625 (void)out;//only to avoid -Wunused-parameter
13626}
13627
13628// --- fasttest.U32Const..ReadFieldMaybe
13629bool fasttest::U32Const_ReadFieldMaybe(fasttest::U32Const& parent, algo::strptr field, algo::strptr strval) {
13630 bool retval = true;
13631 fasttest::FieldId field_id;
13632 (void)value_SetStrptrMaybe(field_id,field);
13633 switch(field_id) {
13634 case fasttest_FieldId_base: {
13635 retval = false;
13636 break;
13637 }
13638 case fasttest_FieldId_length: {
13639 retval = false;
13640 break;
13641 }
13642 case fasttest_FieldId_id: {
13643 retval = false;
13644 break;
13645 }
13646 case fasttest_FieldId_Value: {
13647 retval = true;
13648 break;
13649 }
13650 default: break;
13651 }
13652 if (!retval) {
13653 algo_lib::AppendErrtext("attr",field);
13654 }
13655 (void)parent;//only to avoid -Wunused-parameter
13656 (void)strval;//only to avoid -Wunused-parameter
13657 return retval;
13658}
13659
13660// --- fasttest.U32Const..ReadStrptrMaybe
13661// Read fields of fasttest::U32Const from an ascii string.
13662// The format of the string is an ssim Tuple
13663bool fasttest::U32Const_ReadStrptrMaybe(fasttest::U32Const &parent, algo::strptr in_str) {
13664 bool retval = true;
13665 retval = algo::StripTypeTag(in_str, "fasttest.U32Const");
13666 ind_beg(algo::Attr_curs, attr, in_str) {
13667 retval = retval && U32Const_ReadFieldMaybe(parent, attr.name, attr.value);
13668 }ind_end;
13669 return retval;
13670}
13671
13672// --- fasttest.U32Const..Print
13673// print string representation of ROW to string STR
13674// cfmt:fasttest.U32Const.String printfmt:Tuple
13675void fasttest::U32Const_Print(fasttest::U32Const& row, algo::cstring& str) {
13676 algo::tempstr temp;
13677 str << "fasttest.U32Const";
13678
13679 u32_Print(Value_Get(row), temp);
13680 PrintAttrSpaceReset(str,"Value", temp);
13681}
13682
13683// --- fasttest.U32Const..FastEncode
13684void fasttest::U32Const_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32Const& parent) {
13685 int index = ary_N(buf);
13686 u64 pmap(0);
13687 if (!tid_AssignedQ(state) || parent.id != state.tid) {
13688 lib_fast::EncodeUnsigned(buf,parent.id,false);
13689 lib_fast::SetPmapBit(pmap,0);
13690 }
13691 tid_SetAssigned(state);
13692 state.tid = parent.id;
13693 // Value unsigned constant mandatory
13694 lib_fast::InsertPmap(buf,index,pmap);
13695}
13696
13697// --- fasttest.U32Const..FastDecode
13698bool fasttest::U32Const_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32Const& parent) {
13699 bool ok = true;
13700 // Value unsigned constant mandatory
13701 if (ok) {
13702 }
13703 (void)from;//only to avoid -Wunused-parameter
13704 (void)pmap;//only to avoid -Wunused-parameter
13705 (void)state;//only to avoid -Wunused-parameter
13706 (void)parent;//only to avoid -Wunused-parameter
13707 return ok;
13708}
13709
13710// --- fasttest.U32Const..FixEncode
13711void fasttest::U32Const_FixEncode(cstring& buf, fasttest::U32Const& parent, char soh) {
13712 buf << "1=" << Value_Get(parent) << soh;
13713}
13714
13715// --- fasttest.U32ConstOpt.base.CopyOut
13716// Copy fields out of row
13717void fasttest::parent_CopyOut(fasttest::U32ConstOpt &row, fasttest::TemplateHeader &out) {
13718 // length: field value is computed
13719 // id: field value is computed
13720 (void)row;//only to avoid -Wunused-parameter
13721 (void)out;//only to avoid -Wunused-parameter
13722}
13723
13724// --- fasttest.U32ConstOpt.pmask_bitcurs.Next
13725// proceed to next item
13726void fasttest::U32ConstOpt_pmask_bitcurs_Next(U32ConstOpt_pmask_bitcurs &curs) {
13727 ++curs.bit;
13728 int index = curs.bit / 32;
13729 int offset = curs.bit % 32;
13730 for (; index < curs.n_elems; ++index, offset = 0) {
13731 u64 rest = curs.elems[index] >> offset;
13732 if (rest) {
13733 offset += algo::u64_BitScanForward(rest);
13734 break;
13735 }
13736 }
13737 curs.bit = index * 32 + offset;
13738}
13739
13740// --- fasttest.U32ConstOpt..ReadFieldMaybe
13741bool fasttest::U32ConstOpt_ReadFieldMaybe(fasttest::U32ConstOpt& parent, algo::strptr field, algo::strptr strval) {
13742 bool retval = true;
13743 fasttest::FieldId field_id;
13744 (void)value_SetStrptrMaybe(field_id,field);
13745 switch(field_id) {
13746 case fasttest_FieldId_base: {
13747 retval = false;
13748 break;
13749 }
13750 case fasttest_FieldId_length: {
13751 retval = false;
13752 break;
13753 }
13754 case fasttest_FieldId_id: {
13755 retval = false;
13756 break;
13757 }
13758 case fasttest_FieldId_pmask: {
13759 retval = false;
13760 break;
13761 }
13762 case fasttest_FieldId_Value: {
13763 retval = true;
13764 if (retval) {
13765 pmask_qSetBit(parent, 0);
13766 }
13767 break;
13768 }
13769 default: break;
13770 }
13771 if (!retval) {
13772 algo_lib::AppendErrtext("attr",field);
13773 }
13774 (void)strval;//only to avoid -Wunused-parameter
13775 return retval;
13776}
13777
13778// --- fasttest.U32ConstOpt..ReadStrptrMaybe
13779// Read fields of fasttest::U32ConstOpt from an ascii string.
13780// The format of the string is an ssim Tuple
13781bool fasttest::U32ConstOpt_ReadStrptrMaybe(fasttest::U32ConstOpt &parent, algo::strptr in_str) {
13782 bool retval = true;
13783 retval = algo::StripTypeTag(in_str, "fasttest.U32ConstOpt");
13784 ind_beg(algo::Attr_curs, attr, in_str) {
13785 retval = retval && U32ConstOpt_ReadFieldMaybe(parent, attr.name, attr.value);
13786 }ind_end;
13787 return retval;
13788}
13789
13790// --- fasttest.U32ConstOpt..Print
13791// print string representation of ROW to string STR
13792// cfmt:fasttest.U32ConstOpt.String printfmt:Tuple
13793void fasttest::U32ConstOpt_Print(fasttest::U32ConstOpt& row, algo::cstring& str) {
13794 algo::tempstr temp;
13795 str << "fasttest.U32ConstOpt";
13796
13797 if (Value_PresentQ(row)) {
13798 u32_Print(Value_Get(row), temp);
13799 PrintAttrSpaceReset(str,"Value", temp);
13800 }
13801}
13802
13803// --- fasttest.U32ConstOpt..FastEncode
13804void fasttest::U32ConstOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32ConstOpt& parent) {
13805 int index = ary_N(buf);
13806 u64 pmap(0);
13807 if (!tid_AssignedQ(state) || parent.id != state.tid) {
13808 lib_fast::EncodeUnsigned(buf,parent.id,false);
13809 lib_fast::SetPmapBit(pmap,0);
13810 }
13811 tid_SetAssigned(state);
13812 state.tid = parent.id;
13813 // Value unsigned constant optional
13814 if (Value_PresentQ(parent)) {
13815 lib_fast::SetPmapBit(pmap,1);
13816 }
13817 lib_fast::InsertPmap(buf,index,pmap);
13818}
13819
13820// --- fasttest.U32ConstOpt..FastDecode
13821bool fasttest::U32ConstOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32ConstOpt& parent) {
13822 bool ok = true;
13823 // Value unsigned constant optional
13824 if (ok) {
13825 bool prs = lib_fast::GetPmapBit(pmap,1);
13826 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
13827 }
13828 (void)from;//only to avoid -Wunused-parameter
13829 (void)state;//only to avoid -Wunused-parameter
13830 return ok;
13831}
13832
13833// --- fasttest.U32ConstOpt..FixEncode
13834void fasttest::U32ConstOpt_FixEncode(cstring& buf, fasttest::U32ConstOpt& parent, char soh) {
13835 if (Value_PresentQ(parent)) {
13836 buf << "1=" << Value_Get(parent) << soh;
13837 }
13838}
13839
13840// --- fasttest.U32Copy.base.CopyOut
13841// Copy fields out of row
13842void fasttest::parent_CopyOut(fasttest::U32Copy &row, fasttest::TemplateHeader &out) {
13843 // length: field value is computed
13844 // id: field value is computed
13845 (void)row;//only to avoid -Wunused-parameter
13846 (void)out;//only to avoid -Wunused-parameter
13847}
13848
13849// --- fasttest.U32Copy..ReadFieldMaybe
13850bool fasttest::U32Copy_ReadFieldMaybe(fasttest::U32Copy& parent, algo::strptr field, algo::strptr strval) {
13851 bool retval = true;
13852 fasttest::FieldId field_id;
13853 (void)value_SetStrptrMaybe(field_id,field);
13854 switch(field_id) {
13855 case fasttest_FieldId_base: {
13856 retval = false;
13857 break;
13858 }
13859 case fasttest_FieldId_length: {
13860 retval = false;
13861 break;
13862 }
13863 case fasttest_FieldId_id: {
13864 retval = false;
13865 break;
13866 }
13867 case fasttest_FieldId_Value52: {
13868 retval = u32_ReadStrptrMaybe(parent.Value52, strval);
13869 break;
13870 }
13871 default: break;
13872 }
13873 if (!retval) {
13874 algo_lib::AppendErrtext("attr",field);
13875 }
13876 return retval;
13877}
13878
13879// --- fasttest.U32Copy..ReadStrptrMaybe
13880// Read fields of fasttest::U32Copy from an ascii string.
13881// The format of the string is an ssim Tuple
13882bool fasttest::U32Copy_ReadStrptrMaybe(fasttest::U32Copy &parent, algo::strptr in_str) {
13883 bool retval = true;
13884 retval = algo::StripTypeTag(in_str, "fasttest.U32Copy");
13885 ind_beg(algo::Attr_curs, attr, in_str) {
13886 retval = retval && U32Copy_ReadFieldMaybe(parent, attr.name, attr.value);
13887 }ind_end;
13888 return retval;
13889}
13890
13891// --- fasttest.U32Copy..Print
13892// print string representation of ROW to string STR
13893// cfmt:fasttest.U32Copy.String printfmt:Tuple
13894void fasttest::U32Copy_Print(fasttest::U32Copy& row, algo::cstring& str) {
13895 algo::tempstr temp;
13896 str << "fasttest.U32Copy";
13897
13898 u32_Print(row.Value52, temp);
13899 PrintAttrSpaceReset(str,"Value52", temp);
13900}
13901
13902// --- fasttest.U32Copy..FastEncode
13903void fasttest::U32Copy_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32Copy& parent) {
13904 int index = ary_N(buf);
13905 u64 pmap(0);
13906 if (!tid_AssignedQ(state) || parent.id != state.tid) {
13907 lib_fast::EncodeUnsigned(buf,parent.id,false);
13908 lib_fast::SetPmapBit(pmap,0);
13909 }
13910 tid_SetAssigned(state);
13911 state.tid = parent.id;
13912 // Value52 unsigned copy mandatory
13913 if (Value52_AssignedQ(state) ? parent.Value52 != state.Value52 : parent.Value52 != 52) {
13914 lib_fast::EncodeUnsigned(buf,parent.Value52,false);
13915 lib_fast::SetPmapBit(pmap,1);
13916 }
13917 state.Value52 = parent.Value52;
13918 Value52_SetAssigned(state);
13919 lib_fast::InsertPmap(buf,index,pmap);
13920}
13921
13922// --- fasttest.U32Copy..FastDecode
13923bool fasttest::U32Copy_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32Copy& parent) {
13924 bool ok = true;
13925 // Value52 unsigned copy mandatory
13926 if (ok) {
13927 bool prs = lib_fast::GetPmapBit(pmap,1);
13928 if (prs) {
13929 ok = lib_fast::DecodeUnsigned(from,parent.Value52,false);
13930 if (!ok) {
13931 state.error << "fasttest.U32Copy.Value52: bad Unsigned" << eol;
13932 }
13933 } else if (Value52_AssignedQ(state)) {
13934 parent.Value52 = state.Value52;
13935 } else {
13936 parent.Value52 = 52;
13937 }
13938 Value52_SetAssigned(state);
13939 state.Value52 = parent.Value52;
13940 }
13941 return ok;
13942}
13943
13944// --- fasttest.U32Copy..FixEncode
13945void fasttest::U32Copy_FixEncode(cstring& buf, fasttest::U32Copy& parent, char soh) {
13946 buf << "1=" << parent.Value52 << soh;
13947}
13948
13949// --- fasttest.U32CopyNull.base.CopyOut
13950// Copy fields out of row
13951void fasttest::parent_CopyOut(fasttest::U32CopyNull &row, fasttest::TemplateHeader &out) {
13952 // length: field value is computed
13953 // id: field value is computed
13954 (void)row;//only to avoid -Wunused-parameter
13955 (void)out;//only to avoid -Wunused-parameter
13956}
13957
13958// --- fasttest.U32CopyNull.Value54.ReadStrptrMaybe
13959inline static bool fasttest::Value54_ReadStrptrMaybe(fasttest::U32CopyNull &parent, algo::strptr in_str) {
13960 bool retval = true;
13961 u32 Value54_tmp;
13962 retval = u32_ReadStrptrMaybe(Value54_tmp, in_str);
13963 if (retval) {
13964 Value54_Set(parent, Value54_tmp);
13965 }
13966 return retval;
13967}
13968
13969// --- fasttest.U32CopyNull.pmask_bitcurs.Next
13970// proceed to next item
13971void fasttest::U32CopyNull_pmask_bitcurs_Next(U32CopyNull_pmask_bitcurs &curs) {
13972 ++curs.bit;
13973 int index = curs.bit / 32;
13974 int offset = curs.bit % 32;
13975 for (; index < curs.n_elems; ++index, offset = 0) {
13976 u64 rest = curs.elems[index] >> offset;
13977 if (rest) {
13978 offset += algo::u64_BitScanForward(rest);
13979 break;
13980 }
13981 }
13982 curs.bit = index * 32 + offset;
13983}
13984
13985// --- fasttest.U32CopyNull..ReadFieldMaybe
13986bool fasttest::U32CopyNull_ReadFieldMaybe(fasttest::U32CopyNull& parent, algo::strptr field, algo::strptr strval) {
13987 bool retval = true;
13988 fasttest::FieldId field_id;
13989 (void)value_SetStrptrMaybe(field_id,field);
13990 switch(field_id) {
13991 case fasttest_FieldId_base: {
13992 retval = false;
13993 break;
13994 }
13995 case fasttest_FieldId_length: {
13996 retval = false;
13997 break;
13998 }
13999 case fasttest_FieldId_id: {
14000 retval = false;
14001 break;
14002 }
14003 case fasttest_FieldId_pmask: {
14004 retval = false;
14005 break;
14006 }
14007 case fasttest_FieldId_Value54: {
14008 retval = Value54_ReadStrptrMaybe(parent, strval);
14009 if (retval) {
14010 pmask_qSetBit(parent, 0);
14011 }
14012 break;
14013 }
14014 default: break;
14015 }
14016 if (!retval) {
14017 algo_lib::AppendErrtext("attr",field);
14018 }
14019 return retval;
14020}
14021
14022// --- fasttest.U32CopyNull..ReadStrptrMaybe
14023// Read fields of fasttest::U32CopyNull from an ascii string.
14024// The format of the string is an ssim Tuple
14025bool fasttest::U32CopyNull_ReadStrptrMaybe(fasttest::U32CopyNull &parent, algo::strptr in_str) {
14026 bool retval = true;
14027 retval = algo::StripTypeTag(in_str, "fasttest.U32CopyNull");
14028 ind_beg(algo::Attr_curs, attr, in_str) {
14029 retval = retval && U32CopyNull_ReadFieldMaybe(parent, attr.name, attr.value);
14030 }ind_end;
14031 return retval;
14032}
14033
14034// --- fasttest.U32CopyNull..Print
14035// print string representation of ROW to string STR
14036// cfmt:fasttest.U32CopyNull.String printfmt:Tuple
14037void fasttest::U32CopyNull_Print(fasttest::U32CopyNull& row, algo::cstring& str) {
14038 algo::tempstr temp;
14039 str << "fasttest.U32CopyNull";
14040
14041 if (Value54_PresentQ(row)) {
14042 u32_Print(row.Value54, temp);
14043 PrintAttrSpaceReset(str,"Value54", temp);
14044 }
14045}
14046
14047// --- fasttest.U32CopyNull..FastEncode
14048void fasttest::U32CopyNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32CopyNull& parent) {
14049 int index = ary_N(buf);
14050 u64 pmap(0);
14051 if (!tid_AssignedQ(state) || parent.id != state.tid) {
14052 lib_fast::EncodeUnsigned(buf,parent.id,false);
14053 lib_fast::SetPmapBit(pmap,0);
14054 }
14055 tid_SetAssigned(state);
14056 state.tid = parent.id;
14057 // Value54 unsigned copy optional
14058 if (Value54_PresentQ(parent)) {
14059 if (!Value54_AssignedQ(state) || !Value54_PresentQ(state) || parent.Value54 != state.Value54 ) {
14060 lib_fast::EncodeUnsigned(buf,parent.Value54,true);
14061 lib_fast::SetPmapBit(pmap,1);
14062 }
14063 } else {
14064 if (Value54_AssignedQ(state)) {
14065 lib_fast::EncodeNull(buf);
14066 lib_fast::SetPmapBit(pmap,1);
14067 }
14068 }
14069 state.Value54 = parent.Value54;
14070 present_qSetBitVal(state,Value54_Present_GetBit(state),Value54_PresentQ(parent));
14071 Value54_SetAssigned(state);
14072 lib_fast::InsertPmap(buf,index,pmap);
14073}
14074
14075// --- fasttest.U32CopyNull..FastDecode
14076bool fasttest::U32CopyNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32CopyNull& parent) {
14077 bool ok = true;
14078 // Value54 unsigned copy optional
14079 if (ok) {
14080 bool prs = lib_fast::GetPmapBit(pmap,1);
14081 if (prs) {
14082 prs = !lib_fast::DecodeNull(from);
14083 if (prs) {
14084 ok = lib_fast::DecodeUnsigned(from,parent.Value54,true);
14085 if (!ok) {
14086 state.error << "fasttest.U32CopyNull.Value54: bad Unsigned" << eol;
14087 }
14088 }
14089 } else if (Value54_AssignedQ(state)) {
14090 parent.Value54 = state.Value54;
14091 prs = Value54_PresentQ(state);
14092 } else {
14093 prs = false;
14094 }
14095 pmask_qSetBitVal(parent,Value54_Present_GetBit(parent),prs);
14096 Value54_SetAssigned(state);
14097 present_qSetBitVal(state,Value54_Present_GetBit(state),prs);
14098 state.Value54 = parent.Value54;
14099 }
14100 return ok;
14101}
14102
14103// --- fasttest.U32CopyNull..FixEncode
14104void fasttest::U32CopyNull_FixEncode(cstring& buf, fasttest::U32CopyNull& parent, char soh) {
14105 if (Value54_PresentQ(parent)) {
14106 buf << "1=" << parent.Value54 << soh;
14107 }
14108}
14109
14110// --- fasttest.U32CopyOpt.base.CopyOut
14111// Copy fields out of row
14112void fasttest::parent_CopyOut(fasttest::U32CopyOpt &row, fasttest::TemplateHeader &out) {
14113 // length: field value is computed
14114 // id: field value is computed
14115 (void)row;//only to avoid -Wunused-parameter
14116 (void)out;//only to avoid -Wunused-parameter
14117}
14118
14119// --- fasttest.U32CopyOpt.Value53.ReadStrptrMaybe
14120inline static bool fasttest::Value53_ReadStrptrMaybe(fasttest::U32CopyOpt &parent, algo::strptr in_str) {
14121 bool retval = true;
14122 u32 Value53_tmp;
14123 retval = u32_ReadStrptrMaybe(Value53_tmp, in_str);
14124 if (retval) {
14125 Value53_Set(parent, Value53_tmp);
14126 }
14127 return retval;
14128}
14129
14130// --- fasttest.U32CopyOpt.pmask_bitcurs.Next
14131// proceed to next item
14132void fasttest::U32CopyOpt_pmask_bitcurs_Next(U32CopyOpt_pmask_bitcurs &curs) {
14133 ++curs.bit;
14134 int index = curs.bit / 32;
14135 int offset = curs.bit % 32;
14136 for (; index < curs.n_elems; ++index, offset = 0) {
14137 u64 rest = curs.elems[index] >> offset;
14138 if (rest) {
14139 offset += algo::u64_BitScanForward(rest);
14140 break;
14141 }
14142 }
14143 curs.bit = index * 32 + offset;
14144}
14145
14146// --- fasttest.U32CopyOpt..ReadFieldMaybe
14147bool fasttest::U32CopyOpt_ReadFieldMaybe(fasttest::U32CopyOpt& parent, algo::strptr field, algo::strptr strval) {
14148 bool retval = true;
14149 fasttest::FieldId field_id;
14150 (void)value_SetStrptrMaybe(field_id,field);
14151 switch(field_id) {
14152 case fasttest_FieldId_base: {
14153 retval = false;
14154 break;
14155 }
14156 case fasttest_FieldId_length: {
14157 retval = false;
14158 break;
14159 }
14160 case fasttest_FieldId_id: {
14161 retval = false;
14162 break;
14163 }
14164 case fasttest_FieldId_pmask: {
14165 retval = false;
14166 break;
14167 }
14168 case fasttest_FieldId_Value53: {
14169 retval = Value53_ReadStrptrMaybe(parent, strval);
14170 if (retval) {
14171 pmask_qSetBit(parent, 0);
14172 }
14173 break;
14174 }
14175 default: break;
14176 }
14177 if (!retval) {
14178 algo_lib::AppendErrtext("attr",field);
14179 }
14180 return retval;
14181}
14182
14183// --- fasttest.U32CopyOpt..ReadStrptrMaybe
14184// Read fields of fasttest::U32CopyOpt from an ascii string.
14185// The format of the string is an ssim Tuple
14186bool fasttest::U32CopyOpt_ReadStrptrMaybe(fasttest::U32CopyOpt &parent, algo::strptr in_str) {
14187 bool retval = true;
14188 retval = algo::StripTypeTag(in_str, "fasttest.U32CopyOpt");
14189 ind_beg(algo::Attr_curs, attr, in_str) {
14190 retval = retval && U32CopyOpt_ReadFieldMaybe(parent, attr.name, attr.value);
14191 }ind_end;
14192 return retval;
14193}
14194
14195// --- fasttest.U32CopyOpt..Print
14196// print string representation of ROW to string STR
14197// cfmt:fasttest.U32CopyOpt.String printfmt:Tuple
14198void fasttest::U32CopyOpt_Print(fasttest::U32CopyOpt& row, algo::cstring& str) {
14199 algo::tempstr temp;
14200 str << "fasttest.U32CopyOpt";
14201
14202 if (Value53_PresentQ(row)) {
14203 u32_Print(row.Value53, temp);
14204 PrintAttrSpaceReset(str,"Value53", temp);
14205 }
14206}
14207
14208// --- fasttest.U32CopyOpt..FastEncode
14209void fasttest::U32CopyOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32CopyOpt& parent) {
14210 int index = ary_N(buf);
14211 u64 pmap(0);
14212 if (!tid_AssignedQ(state) || parent.id != state.tid) {
14213 lib_fast::EncodeUnsigned(buf,parent.id,false);
14214 lib_fast::SetPmapBit(pmap,0);
14215 }
14216 tid_SetAssigned(state);
14217 state.tid = parent.id;
14218 // Value53 unsigned copy optional
14219 if (Value53_PresentQ(parent)) {
14220 if (Value53_AssignedQ(state) ? !Value53_PresentQ(state) || parent.Value53 != state.Value53 : parent.Value53 != 53) {
14221 lib_fast::EncodeUnsigned(buf,parent.Value53,true);
14222 lib_fast::SetPmapBit(pmap,1);
14223 }
14224 } else {
14225 if (Value53_AssignedQ(state) && Value53_PresentQ(state)) {
14226 lib_fast::EncodeNull(buf);
14227 lib_fast::SetPmapBit(pmap,1);
14228 }
14229 }
14230 state.Value53 = parent.Value53;
14231 present_qSetBitVal(state,Value53_Present_GetBit(state),Value53_PresentQ(parent));
14232 Value53_SetAssigned(state);
14233 lib_fast::InsertPmap(buf,index,pmap);
14234}
14235
14236// --- fasttest.U32CopyOpt..FastDecode
14237bool fasttest::U32CopyOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32CopyOpt& parent) {
14238 bool ok = true;
14239 // Value53 unsigned copy optional
14240 if (ok) {
14241 bool prs = lib_fast::GetPmapBit(pmap,1);
14242 if (prs) {
14243 prs = !lib_fast::DecodeNull(from);
14244 if (prs) {
14245 ok = lib_fast::DecodeUnsigned(from,parent.Value53,true);
14246 if (!ok) {
14247 state.error << "fasttest.U32CopyOpt.Value53: bad Unsigned" << eol;
14248 }
14249 }
14250 } else if (Value53_AssignedQ(state)) {
14251 parent.Value53 = state.Value53;
14252 prs = Value53_PresentQ(state);
14253 } else {
14254 parent.Value53 = 53;
14255 prs = true;
14256 }
14257 pmask_qSetBitVal(parent,Value53_Present_GetBit(parent),prs);
14258 Value53_SetAssigned(state);
14259 present_qSetBitVal(state,Value53_Present_GetBit(state),prs);
14260 state.Value53 = parent.Value53;
14261 }
14262 return ok;
14263}
14264
14265// --- fasttest.U32CopyOpt..FixEncode
14266void fasttest::U32CopyOpt_FixEncode(cstring& buf, fasttest::U32CopyOpt& parent, char soh) {
14267 if (Value53_PresentQ(parent)) {
14268 buf << "1=" << parent.Value53 << soh;
14269 }
14270}
14271
14272// --- fasttest.U32Delta.base.CopyOut
14273// Copy fields out of row
14274void fasttest::parent_CopyOut(fasttest::U32Delta &row, fasttest::TemplateHeader &out) {
14275 // length: field value is computed
14276 // id: field value is computed
14277 (void)row;//only to avoid -Wunused-parameter
14278 (void)out;//only to avoid -Wunused-parameter
14279}
14280
14281// --- fasttest.U32Delta..ReadFieldMaybe
14282bool fasttest::U32Delta_ReadFieldMaybe(fasttest::U32Delta& parent, algo::strptr field, algo::strptr strval) {
14283 bool retval = true;
14284 fasttest::FieldId field_id;
14285 (void)value_SetStrptrMaybe(field_id,field);
14286 switch(field_id) {
14287 case fasttest_FieldId_base: {
14288 retval = false;
14289 break;
14290 }
14291 case fasttest_FieldId_length: {
14292 retval = false;
14293 break;
14294 }
14295 case fasttest_FieldId_id: {
14296 retval = false;
14297 break;
14298 }
14299 case fasttest_FieldId_Value69: {
14300 retval = u32_ReadStrptrMaybe(parent.Value69, strval);
14301 break;
14302 }
14303 default: break;
14304 }
14305 if (!retval) {
14306 algo_lib::AppendErrtext("attr",field);
14307 }
14308 return retval;
14309}
14310
14311// --- fasttest.U32Delta..ReadStrptrMaybe
14312// Read fields of fasttest::U32Delta from an ascii string.
14313// The format of the string is an ssim Tuple
14314bool fasttest::U32Delta_ReadStrptrMaybe(fasttest::U32Delta &parent, algo::strptr in_str) {
14315 bool retval = true;
14316 retval = algo::StripTypeTag(in_str, "fasttest.U32Delta");
14317 ind_beg(algo::Attr_curs, attr, in_str) {
14318 retval = retval && U32Delta_ReadFieldMaybe(parent, attr.name, attr.value);
14319 }ind_end;
14320 return retval;
14321}
14322
14323// --- fasttest.U32Delta..Print
14324// print string representation of ROW to string STR
14325// cfmt:fasttest.U32Delta.String printfmt:Tuple
14326void fasttest::U32Delta_Print(fasttest::U32Delta& row, algo::cstring& str) {
14327 algo::tempstr temp;
14328 str << "fasttest.U32Delta";
14329
14330 u32_Print(row.Value69, temp);
14331 PrintAttrSpaceReset(str,"Value69", temp);
14332}
14333
14334// --- fasttest.U32Delta..FastEncode
14335void fasttest::U32Delta_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32Delta& parent) {
14336 int index = ary_N(buf);
14337 u64 pmap(0);
14338 if (!tid_AssignedQ(state) || parent.id != state.tid) {
14339 lib_fast::EncodeUnsigned(buf,parent.id,false);
14340 lib_fast::SetPmapBit(pmap,0);
14341 }
14342 tid_SetAssigned(state);
14343 state.tid = parent.id;
14344 // Value69 unsigned delta mandatory
14345 if (!Value69_AssignedQ(state)) {
14346 Value69_SetAssigned(state);
14347 state.Value69 = 69;
14348 }
14349 lib_fast::EncodeDeltaUnsigned(buf,state.Value69,parent.Value69,false);
14350 state.Value69 = parent.Value69;
14351 lib_fast::InsertPmap(buf,index,pmap);
14352}
14353
14354// --- fasttest.U32Delta..FastDecode
14355bool fasttest::U32Delta_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32Delta& parent) {
14356 bool ok = true;
14357 // Value69 unsigned delta mandatory
14358 if (ok) {
14359 if (!Value69_AssignedQ(state)) {
14360 Value69_SetAssigned(state);
14361 state.Value69 = 69;
14362 }
14363 ok = lib_fast::DecodeDeltaUnsigned(from,state.Value69,parent.Value69,false);
14364 if (!ok) {
14365 state.error << "fasttest.U32Delta.Value69: bad Unsigned delta" << eol;
14366 }
14367 state.Value69 = parent.Value69;
14368 }
14369 (void)pmap;//only to avoid -Wunused-parameter
14370 return ok;
14371}
14372
14373// --- fasttest.U32Delta..FixEncode
14374void fasttest::U32Delta_FixEncode(cstring& buf, fasttest::U32Delta& parent, char soh) {
14375 buf << "1=" << parent.Value69 << soh;
14376}
14377
14378// --- fasttest.U32DeltaImpl.base.CopyOut
14379// Copy fields out of row
14380void fasttest::parent_CopyOut(fasttest::U32DeltaImpl &row, fasttest::TemplateHeader &out) {
14381 // length: field value is computed
14382 // id: field value is computed
14383 (void)row;//only to avoid -Wunused-parameter
14384 (void)out;//only to avoid -Wunused-parameter
14385}
14386
14387// --- fasttest.U32DeltaImpl..ReadFieldMaybe
14388bool fasttest::U32DeltaImpl_ReadFieldMaybe(fasttest::U32DeltaImpl& parent, algo::strptr field, algo::strptr strval) {
14389 bool retval = true;
14390 fasttest::FieldId field_id;
14391 (void)value_SetStrptrMaybe(field_id,field);
14392 switch(field_id) {
14393 case fasttest_FieldId_base: {
14394 retval = false;
14395 break;
14396 }
14397 case fasttest_FieldId_length: {
14398 retval = false;
14399 break;
14400 }
14401 case fasttest_FieldId_id: {
14402 retval = false;
14403 break;
14404 }
14405 case fasttest_FieldId_Value70: {
14406 retval = u32_ReadStrptrMaybe(parent.Value70, strval);
14407 break;
14408 }
14409 default: break;
14410 }
14411 if (!retval) {
14412 algo_lib::AppendErrtext("attr",field);
14413 }
14414 return retval;
14415}
14416
14417// --- fasttest.U32DeltaImpl..ReadStrptrMaybe
14418// Read fields of fasttest::U32DeltaImpl from an ascii string.
14419// The format of the string is an ssim Tuple
14420bool fasttest::U32DeltaImpl_ReadStrptrMaybe(fasttest::U32DeltaImpl &parent, algo::strptr in_str) {
14421 bool retval = true;
14422 retval = algo::StripTypeTag(in_str, "fasttest.U32DeltaImpl");
14423 ind_beg(algo::Attr_curs, attr, in_str) {
14424 retval = retval && U32DeltaImpl_ReadFieldMaybe(parent, attr.name, attr.value);
14425 }ind_end;
14426 return retval;
14427}
14428
14429// --- fasttest.U32DeltaImpl..Print
14430// print string representation of ROW to string STR
14431// cfmt:fasttest.U32DeltaImpl.String printfmt:Tuple
14432void fasttest::U32DeltaImpl_Print(fasttest::U32DeltaImpl& row, algo::cstring& str) {
14433 algo::tempstr temp;
14434 str << "fasttest.U32DeltaImpl";
14435
14436 u32_Print(row.Value70, temp);
14437 PrintAttrSpaceReset(str,"Value70", temp);
14438}
14439
14440// --- fasttest.U32DeltaImpl..FastEncode
14441void fasttest::U32DeltaImpl_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32DeltaImpl& parent) {
14442 int index = ary_N(buf);
14443 u64 pmap(0);
14444 if (!tid_AssignedQ(state) || parent.id != state.tid) {
14445 lib_fast::EncodeUnsigned(buf,parent.id,false);
14446 lib_fast::SetPmapBit(pmap,0);
14447 }
14448 tid_SetAssigned(state);
14449 state.tid = parent.id;
14450 // Value70 unsigned delta mandatory
14451 if (!Value70_AssignedQ(state)) {
14452 Value70_SetAssigned(state);
14453 state.Value70 = 0;
14454 }
14455 lib_fast::EncodeDeltaUnsigned(buf,state.Value70,parent.Value70,false);
14456 state.Value70 = parent.Value70;
14457 lib_fast::InsertPmap(buf,index,pmap);
14458}
14459
14460// --- fasttest.U32DeltaImpl..FastDecode
14461bool fasttest::U32DeltaImpl_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32DeltaImpl& parent) {
14462 bool ok = true;
14463 // Value70 unsigned delta mandatory
14464 if (ok) {
14465 if (!Value70_AssignedQ(state)) {
14466 Value70_SetAssigned(state);
14467 state.Value70 = 0;
14468 }
14469 ok = lib_fast::DecodeDeltaUnsigned(from,state.Value70,parent.Value70,false);
14470 if (!ok) {
14471 state.error << "fasttest.U32DeltaImpl.Value70: bad Unsigned delta" << eol;
14472 }
14473 state.Value70 = parent.Value70;
14474 }
14475 (void)pmap;//only to avoid -Wunused-parameter
14476 return ok;
14477}
14478
14479// --- fasttest.U32DeltaImpl..FixEncode
14480void fasttest::U32DeltaImpl_FixEncode(cstring& buf, fasttest::U32DeltaImpl& parent, char soh) {
14481 buf << "1=" << parent.Value70 << soh;
14482}
14483
14484// --- fasttest.U32DeltaNull.base.CopyOut
14485// Copy fields out of row
14486void fasttest::parent_CopyOut(fasttest::U32DeltaNull &row, fasttest::TemplateHeader &out) {
14487 // length: field value is computed
14488 // id: field value is computed
14489 (void)row;//only to avoid -Wunused-parameter
14490 (void)out;//only to avoid -Wunused-parameter
14491}
14492
14493// --- fasttest.U32DeltaNull.Value72.ReadStrptrMaybe
14494inline static bool fasttest::Value72_ReadStrptrMaybe(fasttest::U32DeltaNull &parent, algo::strptr in_str) {
14495 bool retval = true;
14496 u32 Value72_tmp;
14497 retval = u32_ReadStrptrMaybe(Value72_tmp, in_str);
14498 if (retval) {
14499 Value72_Set(parent, Value72_tmp);
14500 }
14501 return retval;
14502}
14503
14504// --- fasttest.U32DeltaNull.pmask_bitcurs.Next
14505// proceed to next item
14506void fasttest::U32DeltaNull_pmask_bitcurs_Next(U32DeltaNull_pmask_bitcurs &curs) {
14507 ++curs.bit;
14508 int index = curs.bit / 32;
14509 int offset = curs.bit % 32;
14510 for (; index < curs.n_elems; ++index, offset = 0) {
14511 u64 rest = curs.elems[index] >> offset;
14512 if (rest) {
14513 offset += algo::u64_BitScanForward(rest);
14514 break;
14515 }
14516 }
14517 curs.bit = index * 32 + offset;
14518}
14519
14520// --- fasttest.U32DeltaNull..ReadFieldMaybe
14521bool fasttest::U32DeltaNull_ReadFieldMaybe(fasttest::U32DeltaNull& parent, algo::strptr field, algo::strptr strval) {
14522 bool retval = true;
14523 fasttest::FieldId field_id;
14524 (void)value_SetStrptrMaybe(field_id,field);
14525 switch(field_id) {
14526 case fasttest_FieldId_base: {
14527 retval = false;
14528 break;
14529 }
14530 case fasttest_FieldId_length: {
14531 retval = false;
14532 break;
14533 }
14534 case fasttest_FieldId_id: {
14535 retval = false;
14536 break;
14537 }
14538 case fasttest_FieldId_pmask: {
14539 retval = false;
14540 break;
14541 }
14542 case fasttest_FieldId_Value72: {
14543 retval = Value72_ReadStrptrMaybe(parent, strval);
14544 if (retval) {
14545 pmask_qSetBit(parent, 0);
14546 }
14547 break;
14548 }
14549 default: break;
14550 }
14551 if (!retval) {
14552 algo_lib::AppendErrtext("attr",field);
14553 }
14554 return retval;
14555}
14556
14557// --- fasttest.U32DeltaNull..ReadStrptrMaybe
14558// Read fields of fasttest::U32DeltaNull from an ascii string.
14559// The format of the string is an ssim Tuple
14560bool fasttest::U32DeltaNull_ReadStrptrMaybe(fasttest::U32DeltaNull &parent, algo::strptr in_str) {
14561 bool retval = true;
14562 retval = algo::StripTypeTag(in_str, "fasttest.U32DeltaNull");
14563 ind_beg(algo::Attr_curs, attr, in_str) {
14564 retval = retval && U32DeltaNull_ReadFieldMaybe(parent, attr.name, attr.value);
14565 }ind_end;
14566 return retval;
14567}
14568
14569// --- fasttest.U32DeltaNull..Print
14570// print string representation of ROW to string STR
14571// cfmt:fasttest.U32DeltaNull.String printfmt:Tuple
14572void fasttest::U32DeltaNull_Print(fasttest::U32DeltaNull& row, algo::cstring& str) {
14573 algo::tempstr temp;
14574 str << "fasttest.U32DeltaNull";
14575
14576 if (Value72_PresentQ(row)) {
14577 u32_Print(row.Value72, temp);
14578 PrintAttrSpaceReset(str,"Value72", temp);
14579 }
14580}
14581
14582// --- fasttest.U32DeltaNull..FastEncode
14583void fasttest::U32DeltaNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32DeltaNull& parent) {
14584 int index = ary_N(buf);
14585 u64 pmap(0);
14586 if (!tid_AssignedQ(state) || parent.id != state.tid) {
14587 lib_fast::EncodeUnsigned(buf,parent.id,false);
14588 lib_fast::SetPmapBit(pmap,0);
14589 }
14590 tid_SetAssigned(state);
14591 state.tid = parent.id;
14592 // Value72 unsigned delta optional
14593 if (!Value72_AssignedQ(state)) {
14594 Value72_SetAssigned(state);
14595 present_qSetBitVal(state,Value72_Present_GetBit(state),Value72_PresentQ(parent));
14596 state.Value72 = 0;
14597 }
14598 if (Value72_PresentQ(parent)) {
14599 if (!Value72_PresentQ(state)) {
14600 state.Value72 = 0;
14601 }
14602 lib_fast::EncodeDeltaUnsigned(buf,state.Value72,parent.Value72,true);
14603 } else {
14604 lib_fast::EncodeNull(buf);
14605 }
14606 state.Value72 = parent.Value72;
14607 present_qSetBitVal(state,Value72_Present_GetBit(state),Value72_PresentQ(parent));
14608 lib_fast::InsertPmap(buf,index,pmap);
14609}
14610
14611// --- fasttest.U32DeltaNull..FastDecode
14612bool fasttest::U32DeltaNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32DeltaNull& parent) {
14613 bool ok = true;
14614 // Value72 unsigned delta optional
14615 if (ok) {
14616 if (!Value72_AssignedQ(state)) {
14617 Value72_SetAssigned(state);
14618 bool prs(true);
14619 present_qSetBitVal(state,Value72_Present_GetBit(state),prs);
14620 state.Value72 = 0;
14621 }
14622 bool prs = !lib_fast::DecodeNull(from);
14623 if (prs) {
14624 if (!Value72_PresentQ(state)) {
14625 state.Value72 = 0;
14626 }
14627 ok = lib_fast::DecodeDeltaUnsigned(from,state.Value72,parent.Value72,true);
14628 if (!ok) {
14629 state.error << "fasttest.U32DeltaNull.Value72: bad Unsigned delta" << eol;
14630 }
14631 state.Value72 = parent.Value72;
14632 }
14633 pmask_qSetBitVal(parent,Value72_Present_GetBit(parent),prs);
14634 present_qSetBitVal(state,Value72_Present_GetBit(state),prs);
14635 }
14636 (void)pmap;//only to avoid -Wunused-parameter
14637 return ok;
14638}
14639
14640// --- fasttest.U32DeltaNull..FixEncode
14641void fasttest::U32DeltaNull_FixEncode(cstring& buf, fasttest::U32DeltaNull& parent, char soh) {
14642 if (Value72_PresentQ(parent)) {
14643 buf << "1=" << parent.Value72 << soh;
14644 }
14645}
14646
14647// --- fasttest.U32DeltaOpt.base.CopyOut
14648// Copy fields out of row
14649void fasttest::parent_CopyOut(fasttest::U32DeltaOpt &row, fasttest::TemplateHeader &out) {
14650 // length: field value is computed
14651 // id: field value is computed
14652 (void)row;//only to avoid -Wunused-parameter
14653 (void)out;//only to avoid -Wunused-parameter
14654}
14655
14656// --- fasttest.U32DeltaOpt.Value71.ReadStrptrMaybe
14657inline static bool fasttest::Value71_ReadStrptrMaybe(fasttest::U32DeltaOpt &parent, algo::strptr in_str) {
14658 bool retval = true;
14659 u32 Value71_tmp;
14660 retval = u32_ReadStrptrMaybe(Value71_tmp, in_str);
14661 if (retval) {
14662 Value71_Set(parent, Value71_tmp);
14663 }
14664 return retval;
14665}
14666
14667// --- fasttest.U32DeltaOpt.pmask_bitcurs.Next
14668// proceed to next item
14669void fasttest::U32DeltaOpt_pmask_bitcurs_Next(U32DeltaOpt_pmask_bitcurs &curs) {
14670 ++curs.bit;
14671 int index = curs.bit / 32;
14672 int offset = curs.bit % 32;
14673 for (; index < curs.n_elems; ++index, offset = 0) {
14674 u64 rest = curs.elems[index] >> offset;
14675 if (rest) {
14676 offset += algo::u64_BitScanForward(rest);
14677 break;
14678 }
14679 }
14680 curs.bit = index * 32 + offset;
14681}
14682
14683// --- fasttest.U32DeltaOpt..ReadFieldMaybe
14684bool fasttest::U32DeltaOpt_ReadFieldMaybe(fasttest::U32DeltaOpt& parent, algo::strptr field, algo::strptr strval) {
14685 bool retval = true;
14686 fasttest::FieldId field_id;
14687 (void)value_SetStrptrMaybe(field_id,field);
14688 switch(field_id) {
14689 case fasttest_FieldId_base: {
14690 retval = false;
14691 break;
14692 }
14693 case fasttest_FieldId_length: {
14694 retval = false;
14695 break;
14696 }
14697 case fasttest_FieldId_id: {
14698 retval = false;
14699 break;
14700 }
14701 case fasttest_FieldId_pmask: {
14702 retval = false;
14703 break;
14704 }
14705 case fasttest_FieldId_Value71: {
14706 retval = Value71_ReadStrptrMaybe(parent, strval);
14707 if (retval) {
14708 pmask_qSetBit(parent, 0);
14709 }
14710 break;
14711 }
14712 default: break;
14713 }
14714 if (!retval) {
14715 algo_lib::AppendErrtext("attr",field);
14716 }
14717 return retval;
14718}
14719
14720// --- fasttest.U32DeltaOpt..ReadStrptrMaybe
14721// Read fields of fasttest::U32DeltaOpt from an ascii string.
14722// The format of the string is an ssim Tuple
14723bool fasttest::U32DeltaOpt_ReadStrptrMaybe(fasttest::U32DeltaOpt &parent, algo::strptr in_str) {
14724 bool retval = true;
14725 retval = algo::StripTypeTag(in_str, "fasttest.U32DeltaOpt");
14726 ind_beg(algo::Attr_curs, attr, in_str) {
14727 retval = retval && U32DeltaOpt_ReadFieldMaybe(parent, attr.name, attr.value);
14728 }ind_end;
14729 return retval;
14730}
14731
14732// --- fasttest.U32DeltaOpt..Print
14733// print string representation of ROW to string STR
14734// cfmt:fasttest.U32DeltaOpt.String printfmt:Tuple
14735void fasttest::U32DeltaOpt_Print(fasttest::U32DeltaOpt& row, algo::cstring& str) {
14736 algo::tempstr temp;
14737 str << "fasttest.U32DeltaOpt";
14738
14739 if (Value71_PresentQ(row)) {
14740 u32_Print(row.Value71, temp);
14741 PrintAttrSpaceReset(str,"Value71", temp);
14742 }
14743}
14744
14745// --- fasttest.U32DeltaOpt..FastEncode
14746void fasttest::U32DeltaOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32DeltaOpt& parent) {
14747 int index = ary_N(buf);
14748 u64 pmap(0);
14749 if (!tid_AssignedQ(state) || parent.id != state.tid) {
14750 lib_fast::EncodeUnsigned(buf,parent.id,false);
14751 lib_fast::SetPmapBit(pmap,0);
14752 }
14753 tid_SetAssigned(state);
14754 state.tid = parent.id;
14755 // Value71 unsigned delta optional
14756 if (!Value71_AssignedQ(state)) {
14757 Value71_SetAssigned(state);
14758 present_qSetBitVal(state,Value71_Present_GetBit(state),Value71_PresentQ(parent));
14759 state.Value71 = 71;
14760 }
14761 if (Value71_PresentQ(parent)) {
14762 if (!Value71_PresentQ(state)) {
14763 state.Value71 = 71;
14764 }
14765 lib_fast::EncodeDeltaUnsigned(buf,state.Value71,parent.Value71,true);
14766 } else {
14767 lib_fast::EncodeNull(buf);
14768 }
14769 state.Value71 = parent.Value71;
14770 present_qSetBitVal(state,Value71_Present_GetBit(state),Value71_PresentQ(parent));
14771 lib_fast::InsertPmap(buf,index,pmap);
14772}
14773
14774// --- fasttest.U32DeltaOpt..FastDecode
14775bool fasttest::U32DeltaOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32DeltaOpt& parent) {
14776 bool ok = true;
14777 // Value71 unsigned delta optional
14778 if (ok) {
14779 if (!Value71_AssignedQ(state)) {
14780 Value71_SetAssigned(state);
14781 bool prs(true);
14782 present_qSetBitVal(state,Value71_Present_GetBit(state),prs);
14783 state.Value71 = 71;
14784 }
14785 bool prs = !lib_fast::DecodeNull(from);
14786 if (prs) {
14787 if (!Value71_PresentQ(state)) {
14788 state.Value71 = 71;
14789 }
14790 ok = lib_fast::DecodeDeltaUnsigned(from,state.Value71,parent.Value71,true);
14791 if (!ok) {
14792 state.error << "fasttest.U32DeltaOpt.Value71: bad Unsigned delta" << eol;
14793 }
14794 state.Value71 = parent.Value71;
14795 }
14796 pmask_qSetBitVal(parent,Value71_Present_GetBit(parent),prs);
14797 present_qSetBitVal(state,Value71_Present_GetBit(state),prs);
14798 }
14799 (void)pmap;//only to avoid -Wunused-parameter
14800 return ok;
14801}
14802
14803// --- fasttest.U32DeltaOpt..FixEncode
14804void fasttest::U32DeltaOpt_FixEncode(cstring& buf, fasttest::U32DeltaOpt& parent, char soh) {
14805 if (Value71_PresentQ(parent)) {
14806 buf << "1=" << parent.Value71 << soh;
14807 }
14808}
14809
14810// --- fasttest.U32Dflt.base.CopyOut
14811// Copy fields out of row
14812void fasttest::parent_CopyOut(fasttest::U32Dflt &row, fasttest::TemplateHeader &out) {
14813 // length: field value is computed
14814 // id: field value is computed
14815 (void)row;//only to avoid -Wunused-parameter
14816 (void)out;//only to avoid -Wunused-parameter
14817}
14818
14819// --- fasttest.U32Dflt..ReadFieldMaybe
14820bool fasttest::U32Dflt_ReadFieldMaybe(fasttest::U32Dflt& parent, algo::strptr field, algo::strptr strval) {
14821 bool retval = true;
14822 fasttest::FieldId field_id;
14823 (void)value_SetStrptrMaybe(field_id,field);
14824 switch(field_id) {
14825 case fasttest_FieldId_base: {
14826 retval = false;
14827 break;
14828 }
14829 case fasttest_FieldId_length: {
14830 retval = false;
14831 break;
14832 }
14833 case fasttest_FieldId_id: {
14834 retval = false;
14835 break;
14836 }
14837 case fasttest_FieldId_Value: {
14838 retval = u32_ReadStrptrMaybe(parent.Value, strval);
14839 break;
14840 }
14841 default: break;
14842 }
14843 if (!retval) {
14844 algo_lib::AppendErrtext("attr",field);
14845 }
14846 return retval;
14847}
14848
14849// --- fasttest.U32Dflt..ReadStrptrMaybe
14850// Read fields of fasttest::U32Dflt from an ascii string.
14851// The format of the string is an ssim Tuple
14852bool fasttest::U32Dflt_ReadStrptrMaybe(fasttest::U32Dflt &parent, algo::strptr in_str) {
14853 bool retval = true;
14854 retval = algo::StripTypeTag(in_str, "fasttest.U32Dflt");
14855 ind_beg(algo::Attr_curs, attr, in_str) {
14856 retval = retval && U32Dflt_ReadFieldMaybe(parent, attr.name, attr.value);
14857 }ind_end;
14858 return retval;
14859}
14860
14861// --- fasttest.U32Dflt..Print
14862// print string representation of ROW to string STR
14863// cfmt:fasttest.U32Dflt.String printfmt:Tuple
14864void fasttest::U32Dflt_Print(fasttest::U32Dflt& row, algo::cstring& str) {
14865 algo::tempstr temp;
14866 str << "fasttest.U32Dflt";
14867
14868 u32_Print(row.Value, temp);
14869 PrintAttrSpaceReset(str,"Value", temp);
14870}
14871
14872// --- fasttest.U32Dflt..FastEncode
14873void fasttest::U32Dflt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32Dflt& parent) {
14874 int index = ary_N(buf);
14875 u64 pmap(0);
14876 if (!tid_AssignedQ(state) || parent.id != state.tid) {
14877 lib_fast::EncodeUnsigned(buf,parent.id,false);
14878 lib_fast::SetPmapBit(pmap,0);
14879 }
14880 tid_SetAssigned(state);
14881 state.tid = parent.id;
14882 // Value unsigned default mandatory
14883 if (parent.Value != 36) {
14884 lib_fast::EncodeUnsigned(buf,parent.Value,false);
14885 lib_fast::SetPmapBit(pmap,1);
14886 }
14887 lib_fast::InsertPmap(buf,index,pmap);
14888}
14889
14890// --- fasttest.U32Dflt..FastDecode
14891bool fasttest::U32Dflt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32Dflt& parent) {
14892 bool ok = true;
14893 // Value unsigned default mandatory
14894 if (ok) {
14895 bool prs = lib_fast::GetPmapBit(pmap,1);
14896 if (prs) {
14897 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
14898 if (!ok) {
14899 state.error << "fasttest.U32Dflt.Value: bad Unsigned" << eol;
14900 }
14901 } else {
14902 parent.Value = 36;
14903 }
14904 }
14905 return ok;
14906}
14907
14908// --- fasttest.U32Dflt..FixEncode
14909void fasttest::U32Dflt_FixEncode(cstring& buf, fasttest::U32Dflt& parent, char soh) {
14910 buf << "1=" << parent.Value << soh;
14911}
14912
14913// --- fasttest.U32DfltNull.base.CopyOut
14914// Copy fields out of row
14915void fasttest::parent_CopyOut(fasttest::U32DfltNull &row, fasttest::TemplateHeader &out) {
14916 // length: field value is computed
14917 // id: field value is computed
14918 (void)row;//only to avoid -Wunused-parameter
14919 (void)out;//only to avoid -Wunused-parameter
14920}
14921
14922// --- fasttest.U32DfltNull.Value.ReadStrptrMaybe
14923inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::U32DfltNull &parent, algo::strptr in_str) {
14924 bool retval = true;
14925 u32 Value_tmp;
14926 retval = u32_ReadStrptrMaybe(Value_tmp, in_str);
14927 if (retval) {
14928 Value_Set(parent, Value_tmp);
14929 }
14930 return retval;
14931}
14932
14933// --- fasttest.U32DfltNull.pmask_bitcurs.Next
14934// proceed to next item
14935void fasttest::U32DfltNull_pmask_bitcurs_Next(U32DfltNull_pmask_bitcurs &curs) {
14936 ++curs.bit;
14937 int index = curs.bit / 32;
14938 int offset = curs.bit % 32;
14939 for (; index < curs.n_elems; ++index, offset = 0) {
14940 u64 rest = curs.elems[index] >> offset;
14941 if (rest) {
14942 offset += algo::u64_BitScanForward(rest);
14943 break;
14944 }
14945 }
14946 curs.bit = index * 32 + offset;
14947}
14948
14949// --- fasttest.U32DfltNull..ReadFieldMaybe
14950bool fasttest::U32DfltNull_ReadFieldMaybe(fasttest::U32DfltNull& parent, algo::strptr field, algo::strptr strval) {
14951 bool retval = true;
14952 fasttest::FieldId field_id;
14953 (void)value_SetStrptrMaybe(field_id,field);
14954 switch(field_id) {
14955 case fasttest_FieldId_base: {
14956 retval = false;
14957 break;
14958 }
14959 case fasttest_FieldId_length: {
14960 retval = false;
14961 break;
14962 }
14963 case fasttest_FieldId_id: {
14964 retval = false;
14965 break;
14966 }
14967 case fasttest_FieldId_pmask: {
14968 retval = false;
14969 break;
14970 }
14971 case fasttest_FieldId_Value: {
14972 retval = Value_ReadStrptrMaybe(parent, strval);
14973 if (retval) {
14974 pmask_qSetBit(parent, 0);
14975 }
14976 break;
14977 }
14978 default: break;
14979 }
14980 if (!retval) {
14981 algo_lib::AppendErrtext("attr",field);
14982 }
14983 return retval;
14984}
14985
14986// --- fasttest.U32DfltNull..ReadStrptrMaybe
14987// Read fields of fasttest::U32DfltNull from an ascii string.
14988// The format of the string is an ssim Tuple
14989bool fasttest::U32DfltNull_ReadStrptrMaybe(fasttest::U32DfltNull &parent, algo::strptr in_str) {
14990 bool retval = true;
14991 retval = algo::StripTypeTag(in_str, "fasttest.U32DfltNull");
14992 ind_beg(algo::Attr_curs, attr, in_str) {
14993 retval = retval && U32DfltNull_ReadFieldMaybe(parent, attr.name, attr.value);
14994 }ind_end;
14995 return retval;
14996}
14997
14998// --- fasttest.U32DfltNull..Print
14999// print string representation of ROW to string STR
15000// cfmt:fasttest.U32DfltNull.String printfmt:Tuple
15001void fasttest::U32DfltNull_Print(fasttest::U32DfltNull& row, algo::cstring& str) {
15002 algo::tempstr temp;
15003 str << "fasttest.U32DfltNull";
15004
15005 if (Value_PresentQ(row)) {
15006 u32_Print(row.Value, temp);
15007 PrintAttrSpaceReset(str,"Value", temp);
15008 }
15009}
15010
15011// --- fasttest.U32DfltNull..FastEncode
15012void fasttest::U32DfltNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32DfltNull& parent) {
15013 int index = ary_N(buf);
15014 u64 pmap(0);
15015 if (!tid_AssignedQ(state) || parent.id != state.tid) {
15016 lib_fast::EncodeUnsigned(buf,parent.id,false);
15017 lib_fast::SetPmapBit(pmap,0);
15018 }
15019 tid_SetAssigned(state);
15020 state.tid = parent.id;
15021 // Value unsigned default optional
15022 if (Value_PresentQ(parent)) {
15023 lib_fast::EncodeUnsigned(buf,parent.Value,true);
15024 lib_fast::SetPmapBit(pmap,1);
15025 }
15026 lib_fast::InsertPmap(buf,index,pmap);
15027}
15028
15029// --- fasttest.U32DfltNull..FastDecode
15030bool fasttest::U32DfltNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32DfltNull& parent) {
15031 bool ok = true;
15032 // Value unsigned default optional
15033 if (ok) {
15034 bool prs = lib_fast::GetPmapBit(pmap,1);
15035 if (prs) {
15036 prs = !lib_fast::DecodeNull(from);
15037 if (prs) {
15038 ok = lib_fast::DecodeUnsigned(from,parent.Value,true);
15039 if (!ok) {
15040 state.error << "fasttest.U32DfltNull.Value: bad Unsigned" << eol;
15041 }
15042 }
15043 } else {
15044 }
15045 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
15046 }
15047 return ok;
15048}
15049
15050// --- fasttest.U32DfltNull..FixEncode
15051void fasttest::U32DfltNull_FixEncode(cstring& buf, fasttest::U32DfltNull& parent, char soh) {
15052 if (Value_PresentQ(parent)) {
15053 buf << "1=" << parent.Value << soh;
15054 }
15055}
15056
15057// --- fasttest.U32DfltOpt.base.CopyOut
15058// Copy fields out of row
15059void fasttest::parent_CopyOut(fasttest::U32DfltOpt &row, fasttest::TemplateHeader &out) {
15060 // length: field value is computed
15061 // id: field value is computed
15062 (void)row;//only to avoid -Wunused-parameter
15063 (void)out;//only to avoid -Wunused-parameter
15064}
15065
15066// --- fasttest.U32DfltOpt.Value.ReadStrptrMaybe
15067inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::U32DfltOpt &parent, algo::strptr in_str) {
15068 bool retval = true;
15069 u32 Value_tmp;
15070 retval = u32_ReadStrptrMaybe(Value_tmp, in_str);
15071 if (retval) {
15072 Value_Set(parent, Value_tmp);
15073 }
15074 return retval;
15075}
15076
15077// --- fasttest.U32DfltOpt.pmask_bitcurs.Next
15078// proceed to next item
15079void fasttest::U32DfltOpt_pmask_bitcurs_Next(U32DfltOpt_pmask_bitcurs &curs) {
15080 ++curs.bit;
15081 int index = curs.bit / 32;
15082 int offset = curs.bit % 32;
15083 for (; index < curs.n_elems; ++index, offset = 0) {
15084 u64 rest = curs.elems[index] >> offset;
15085 if (rest) {
15086 offset += algo::u64_BitScanForward(rest);
15087 break;
15088 }
15089 }
15090 curs.bit = index * 32 + offset;
15091}
15092
15093// --- fasttest.U32DfltOpt..ReadFieldMaybe
15094bool fasttest::U32DfltOpt_ReadFieldMaybe(fasttest::U32DfltOpt& parent, algo::strptr field, algo::strptr strval) {
15095 bool retval = true;
15096 fasttest::FieldId field_id;
15097 (void)value_SetStrptrMaybe(field_id,field);
15098 switch(field_id) {
15099 case fasttest_FieldId_base: {
15100 retval = false;
15101 break;
15102 }
15103 case fasttest_FieldId_length: {
15104 retval = false;
15105 break;
15106 }
15107 case fasttest_FieldId_id: {
15108 retval = false;
15109 break;
15110 }
15111 case fasttest_FieldId_pmask: {
15112 retval = false;
15113 break;
15114 }
15115 case fasttest_FieldId_Value: {
15116 retval = Value_ReadStrptrMaybe(parent, strval);
15117 if (retval) {
15118 pmask_qSetBit(parent, 0);
15119 }
15120 break;
15121 }
15122 default: break;
15123 }
15124 if (!retval) {
15125 algo_lib::AppendErrtext("attr",field);
15126 }
15127 return retval;
15128}
15129
15130// --- fasttest.U32DfltOpt..ReadStrptrMaybe
15131// Read fields of fasttest::U32DfltOpt from an ascii string.
15132// The format of the string is an ssim Tuple
15133bool fasttest::U32DfltOpt_ReadStrptrMaybe(fasttest::U32DfltOpt &parent, algo::strptr in_str) {
15134 bool retval = true;
15135 retval = algo::StripTypeTag(in_str, "fasttest.U32DfltOpt");
15136 ind_beg(algo::Attr_curs, attr, in_str) {
15137 retval = retval && U32DfltOpt_ReadFieldMaybe(parent, attr.name, attr.value);
15138 }ind_end;
15139 return retval;
15140}
15141
15142// --- fasttest.U32DfltOpt..Print
15143// print string representation of ROW to string STR
15144// cfmt:fasttest.U32DfltOpt.String printfmt:Tuple
15145void fasttest::U32DfltOpt_Print(fasttest::U32DfltOpt& row, algo::cstring& str) {
15146 algo::tempstr temp;
15147 str << "fasttest.U32DfltOpt";
15148
15149 if (Value_PresentQ(row)) {
15150 u32_Print(row.Value, temp);
15151 PrintAttrSpaceReset(str,"Value", temp);
15152 }
15153}
15154
15155// --- fasttest.U32DfltOpt..FastEncode
15156void fasttest::U32DfltOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32DfltOpt& parent) {
15157 int index = ary_N(buf);
15158 u64 pmap(0);
15159 if (!tid_AssignedQ(state) || parent.id != state.tid) {
15160 lib_fast::EncodeUnsigned(buf,parent.id,false);
15161 lib_fast::SetPmapBit(pmap,0);
15162 }
15163 tid_SetAssigned(state);
15164 state.tid = parent.id;
15165 // Value unsigned default optional
15166 if (Value_PresentQ(parent)) {
15167 if (parent.Value != 37) {
15168 lib_fast::EncodeUnsigned(buf,parent.Value,true);
15169 lib_fast::SetPmapBit(pmap,1);
15170 }
15171 } else {
15172 lib_fast::EncodeNull(buf);
15173 lib_fast::SetPmapBit(pmap,1);
15174 }
15175 lib_fast::InsertPmap(buf,index,pmap);
15176}
15177
15178// --- fasttest.U32DfltOpt..FastDecode
15179bool fasttest::U32DfltOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32DfltOpt& parent) {
15180 bool ok = true;
15181 // Value unsigned default optional
15182 if (ok) {
15183 bool prs = lib_fast::GetPmapBit(pmap,1);
15184 if (prs) {
15185 prs = !lib_fast::DecodeNull(from);
15186 if (prs) {
15187 ok = lib_fast::DecodeUnsigned(from,parent.Value,true);
15188 if (!ok) {
15189 state.error << "fasttest.U32DfltOpt.Value: bad Unsigned" << eol;
15190 }
15191 }
15192 } else {
15193 parent.Value = 37;
15194 prs = true;
15195 }
15196 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
15197 }
15198 return ok;
15199}
15200
15201// --- fasttest.U32DfltOpt..FixEncode
15202void fasttest::U32DfltOpt_FixEncode(cstring& buf, fasttest::U32DfltOpt& parent, char soh) {
15203 if (Value_PresentQ(parent)) {
15204 buf << "1=" << parent.Value << soh;
15205 }
15206}
15207
15208// --- fasttest.U32Incr.base.CopyOut
15209// Copy fields out of row
15210void fasttest::parent_CopyOut(fasttest::U32Incr &row, fasttest::TemplateHeader &out) {
15211 // length: field value is computed
15212 // id: field value is computed
15213 (void)row;//only to avoid -Wunused-parameter
15214 (void)out;//only to avoid -Wunused-parameter
15215}
15216
15217// --- fasttest.U32Incr..ReadFieldMaybe
15218bool fasttest::U32Incr_ReadFieldMaybe(fasttest::U32Incr& parent, algo::strptr field, algo::strptr strval) {
15219 bool retval = true;
15220 fasttest::FieldId field_id;
15221 (void)value_SetStrptrMaybe(field_id,field);
15222 switch(field_id) {
15223 case fasttest_FieldId_base: {
15224 retval = false;
15225 break;
15226 }
15227 case fasttest_FieldId_length: {
15228 retval = false;
15229 break;
15230 }
15231 case fasttest_FieldId_id: {
15232 retval = false;
15233 break;
15234 }
15235 case fasttest_FieldId_Value101: {
15236 retval = u32_ReadStrptrMaybe(parent.Value101, strval);
15237 break;
15238 }
15239 default: break;
15240 }
15241 if (!retval) {
15242 algo_lib::AppendErrtext("attr",field);
15243 }
15244 return retval;
15245}
15246
15247// --- fasttest.U32Incr..ReadStrptrMaybe
15248// Read fields of fasttest::U32Incr from an ascii string.
15249// The format of the string is an ssim Tuple
15250bool fasttest::U32Incr_ReadStrptrMaybe(fasttest::U32Incr &parent, algo::strptr in_str) {
15251 bool retval = true;
15252 retval = algo::StripTypeTag(in_str, "fasttest.U32Incr");
15253 ind_beg(algo::Attr_curs, attr, in_str) {
15254 retval = retval && U32Incr_ReadFieldMaybe(parent, attr.name, attr.value);
15255 }ind_end;
15256 return retval;
15257}
15258
15259// --- fasttest.U32Incr..Print
15260// print string representation of ROW to string STR
15261// cfmt:fasttest.U32Incr.String printfmt:Tuple
15262void fasttest::U32Incr_Print(fasttest::U32Incr& row, algo::cstring& str) {
15263 algo::tempstr temp;
15264 str << "fasttest.U32Incr";
15265
15266 u32_Print(row.Value101, temp);
15267 PrintAttrSpaceReset(str,"Value101", temp);
15268}
15269
15270// --- fasttest.U32Incr..FastEncode
15271void fasttest::U32Incr_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32Incr& parent) {
15272 int index = ary_N(buf);
15273 u64 pmap(0);
15274 if (!tid_AssignedQ(state) || parent.id != state.tid) {
15275 lib_fast::EncodeUnsigned(buf,parent.id,false);
15276 lib_fast::SetPmapBit(pmap,0);
15277 }
15278 tid_SetAssigned(state);
15279 state.tid = parent.id;
15280 // Value101 unsigned increment mandatory
15281 if (Value101_AssignedQ(state)) {
15282 if (parent.Value101 != state.Value101 + 1) {
15283 lib_fast::EncodeUnsigned(buf,parent.Value101,false);
15284 lib_fast::SetPmapBit(pmap,1);
15285 }
15286 } else {
15287 if (parent.Value101 != 101) {
15288 lib_fast::EncodeUnsigned(buf,parent.Value101,false);
15289 lib_fast::SetPmapBit(pmap,1);
15290 }
15291 }
15292 state.Value101 = parent.Value101;
15293 Value101_SetAssigned(state);
15294 lib_fast::InsertPmap(buf,index,pmap);
15295}
15296
15297// --- fasttest.U32Incr..FastDecode
15298bool fasttest::U32Incr_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32Incr& parent) {
15299 bool ok = true;
15300 // Value101 unsigned increment mandatory
15301 if (ok) {
15302 bool prs = lib_fast::GetPmapBit(pmap,1);
15303 if (prs) {
15304 ok = lib_fast::DecodeUnsigned(from,parent.Value101,false);
15305 if (!ok) {
15306 state.error << "fasttest.U32Incr.Value101: bad Unsigned" << eol;
15307 }
15308 } else if (Value101_AssignedQ(state)) {
15309 parent.Value101 = state.Value101 + 1;
15310 } else {
15311 parent.Value101 = 101;
15312 }
15313 Value101_SetAssigned(state);
15314 state.Value101 = parent.Value101;
15315 }
15316 return ok;
15317}
15318
15319// --- fasttest.U32Incr..FixEncode
15320void fasttest::U32Incr_FixEncode(cstring& buf, fasttest::U32Incr& parent, char soh) {
15321 buf << "1=" << parent.Value101 << soh;
15322}
15323
15324// --- fasttest.U32IncrNV.base.CopyOut
15325// Copy fields out of row
15326void fasttest::parent_CopyOut(fasttest::U32IncrNV &row, fasttest::TemplateHeader &out) {
15327 // length: field value is computed
15328 // id: field value is computed
15329 (void)row;//only to avoid -Wunused-parameter
15330 (void)out;//only to avoid -Wunused-parameter
15331}
15332
15333// --- fasttest.U32IncrNV..ReadFieldMaybe
15334bool fasttest::U32IncrNV_ReadFieldMaybe(fasttest::U32IncrNV& parent, algo::strptr field, algo::strptr strval) {
15335 bool retval = true;
15336 fasttest::FieldId field_id;
15337 (void)value_SetStrptrMaybe(field_id,field);
15338 switch(field_id) {
15339 case fasttest_FieldId_base: {
15340 retval = false;
15341 break;
15342 }
15343 case fasttest_FieldId_length: {
15344 retval = false;
15345 break;
15346 }
15347 case fasttest_FieldId_id: {
15348 retval = false;
15349 break;
15350 }
15351 case fasttest_FieldId_Value102: {
15352 retval = u32_ReadStrptrMaybe(parent.Value102, strval);
15353 break;
15354 }
15355 default: break;
15356 }
15357 if (!retval) {
15358 algo_lib::AppendErrtext("attr",field);
15359 }
15360 return retval;
15361}
15362
15363// --- fasttest.U32IncrNV..ReadStrptrMaybe
15364// Read fields of fasttest::U32IncrNV from an ascii string.
15365// The format of the string is an ssim Tuple
15366bool fasttest::U32IncrNV_ReadStrptrMaybe(fasttest::U32IncrNV &parent, algo::strptr in_str) {
15367 bool retval = true;
15368 retval = algo::StripTypeTag(in_str, "fasttest.U32IncrNV");
15369 ind_beg(algo::Attr_curs, attr, in_str) {
15370 retval = retval && U32IncrNV_ReadFieldMaybe(parent, attr.name, attr.value);
15371 }ind_end;
15372 return retval;
15373}
15374
15375// --- fasttest.U32IncrNV..Print
15376// print string representation of ROW to string STR
15377// cfmt:fasttest.U32IncrNV.String printfmt:Tuple
15378void fasttest::U32IncrNV_Print(fasttest::U32IncrNV& row, algo::cstring& str) {
15379 algo::tempstr temp;
15380 str << "fasttest.U32IncrNV";
15381
15382 u32_Print(row.Value102, temp);
15383 PrintAttrSpaceReset(str,"Value102", temp);
15384}
15385
15386// --- fasttest.U32IncrNV..FastEncode
15387void fasttest::U32IncrNV_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32IncrNV& parent) {
15388 int index = ary_N(buf);
15389 u64 pmap(0);
15390 if (!tid_AssignedQ(state) || parent.id != state.tid) {
15391 lib_fast::EncodeUnsigned(buf,parent.id,false);
15392 lib_fast::SetPmapBit(pmap,0);
15393 }
15394 tid_SetAssigned(state);
15395 state.tid = parent.id;
15396 // Value102 unsigned increment mandatory
15397 if (Value102_AssignedQ(state)) {
15398 if (parent.Value102 != state.Value102 + 1) {
15399 lib_fast::EncodeUnsigned(buf,parent.Value102,false);
15400 lib_fast::SetPmapBit(pmap,1);
15401 }
15402 } else {
15403 lib_fast::EncodeUnsigned(buf,parent.Value102,false);
15404 lib_fast::SetPmapBit(pmap,1);
15405 }
15406 state.Value102 = parent.Value102;
15407 Value102_SetAssigned(state);
15408 lib_fast::InsertPmap(buf,index,pmap);
15409}
15410
15411// --- fasttest.U32IncrNV..FastDecode
15412bool fasttest::U32IncrNV_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32IncrNV& parent) {
15413 bool ok = true;
15414 // Value102 unsigned increment mandatory
15415 if (ok) {
15416 bool prs = lib_fast::GetPmapBit(pmap,1);
15417 if (prs) {
15418 ok = lib_fast::DecodeUnsigned(from,parent.Value102,false);
15419 if (!ok) {
15420 state.error << "fasttest.U32IncrNV.Value102: bad Unsigned" << eol;
15421 }
15422 } else if (Value102_AssignedQ(state)) {
15423 parent.Value102 = state.Value102 + 1;
15424 } else {
15425 ok = false;
15426 state.error << "fasttest.U32IncrNV.Value102: increment operator: previous value unassigned" << eol;
15427 }
15428 Value102_SetAssigned(state);
15429 state.Value102 = parent.Value102;
15430 }
15431 return ok;
15432}
15433
15434// --- fasttest.U32IncrNV..FixEncode
15435void fasttest::U32IncrNV_FixEncode(cstring& buf, fasttest::U32IncrNV& parent, char soh) {
15436 buf << "1=" << parent.Value102 << soh;
15437}
15438
15439// --- fasttest.U32IncrNull.base.CopyOut
15440// Copy fields out of row
15441void fasttest::parent_CopyOut(fasttest::U32IncrNull &row, fasttest::TemplateHeader &out) {
15442 // length: field value is computed
15443 // id: field value is computed
15444 (void)row;//only to avoid -Wunused-parameter
15445 (void)out;//only to avoid -Wunused-parameter
15446}
15447
15448// --- fasttest.U32IncrNull.Value104.ReadStrptrMaybe
15449inline static bool fasttest::Value104_ReadStrptrMaybe(fasttest::U32IncrNull &parent, algo::strptr in_str) {
15450 bool retval = true;
15451 u32 Value104_tmp;
15452 retval = u32_ReadStrptrMaybe(Value104_tmp, in_str);
15453 if (retval) {
15454 Value104_Set(parent, Value104_tmp);
15455 }
15456 return retval;
15457}
15458
15459// --- fasttest.U32IncrNull.pmask_bitcurs.Next
15460// proceed to next item
15461void fasttest::U32IncrNull_pmask_bitcurs_Next(U32IncrNull_pmask_bitcurs &curs) {
15462 ++curs.bit;
15463 int index = curs.bit / 32;
15464 int offset = curs.bit % 32;
15465 for (; index < curs.n_elems; ++index, offset = 0) {
15466 u64 rest = curs.elems[index] >> offset;
15467 if (rest) {
15468 offset += algo::u64_BitScanForward(rest);
15469 break;
15470 }
15471 }
15472 curs.bit = index * 32 + offset;
15473}
15474
15475// --- fasttest.U32IncrNull..ReadFieldMaybe
15476bool fasttest::U32IncrNull_ReadFieldMaybe(fasttest::U32IncrNull& parent, algo::strptr field, algo::strptr strval) {
15477 bool retval = true;
15478 fasttest::FieldId field_id;
15479 (void)value_SetStrptrMaybe(field_id,field);
15480 switch(field_id) {
15481 case fasttest_FieldId_base: {
15482 retval = false;
15483 break;
15484 }
15485 case fasttest_FieldId_length: {
15486 retval = false;
15487 break;
15488 }
15489 case fasttest_FieldId_id: {
15490 retval = false;
15491 break;
15492 }
15493 case fasttest_FieldId_pmask: {
15494 retval = false;
15495 break;
15496 }
15497 case fasttest_FieldId_Value104: {
15498 retval = Value104_ReadStrptrMaybe(parent, strval);
15499 if (retval) {
15500 pmask_qSetBit(parent, 0);
15501 }
15502 break;
15503 }
15504 default: break;
15505 }
15506 if (!retval) {
15507 algo_lib::AppendErrtext("attr",field);
15508 }
15509 return retval;
15510}
15511
15512// --- fasttest.U32IncrNull..ReadStrptrMaybe
15513// Read fields of fasttest::U32IncrNull from an ascii string.
15514// The format of the string is an ssim Tuple
15515bool fasttest::U32IncrNull_ReadStrptrMaybe(fasttest::U32IncrNull &parent, algo::strptr in_str) {
15516 bool retval = true;
15517 retval = algo::StripTypeTag(in_str, "fasttest.U32IncrNull");
15518 ind_beg(algo::Attr_curs, attr, in_str) {
15519 retval = retval && U32IncrNull_ReadFieldMaybe(parent, attr.name, attr.value);
15520 }ind_end;
15521 return retval;
15522}
15523
15524// --- fasttest.U32IncrNull..Print
15525// print string representation of ROW to string STR
15526// cfmt:fasttest.U32IncrNull.String printfmt:Tuple
15527void fasttest::U32IncrNull_Print(fasttest::U32IncrNull& row, algo::cstring& str) {
15528 algo::tempstr temp;
15529 str << "fasttest.U32IncrNull";
15530
15531 if (Value104_PresentQ(row)) {
15532 u32_Print(row.Value104, temp);
15533 PrintAttrSpaceReset(str,"Value104", temp);
15534 }
15535}
15536
15537// --- fasttest.U32IncrNull..FastEncode
15538void fasttest::U32IncrNull_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32IncrNull& parent) {
15539 int index = ary_N(buf);
15540 u64 pmap(0);
15541 if (!tid_AssignedQ(state) || parent.id != state.tid) {
15542 lib_fast::EncodeUnsigned(buf,parent.id,false);
15543 lib_fast::SetPmapBit(pmap,0);
15544 }
15545 tid_SetAssigned(state);
15546 state.tid = parent.id;
15547 // Value104 unsigned increment optional
15548 if (Value104_PresentQ(parent)) {
15549 if (Value104_AssignedQ(state)) {
15550 if (!Value104_PresentQ(state) || parent.Value104 != state.Value104 + 1) {
15551 lib_fast::EncodeUnsigned(buf,parent.Value104,true);
15552 lib_fast::SetPmapBit(pmap,1);
15553 }
15554 } else {
15555 lib_fast::EncodeUnsigned(buf,parent.Value104,true);
15556 lib_fast::SetPmapBit(pmap,1);
15557 }
15558 } else {
15559 if (!Value104_AssignedQ(state) || Value104_PresentQ(state)) {
15560 lib_fast::EncodeNull(buf);
15561 lib_fast::SetPmapBit(pmap,1);
15562 }
15563 }
15564 state.Value104 = parent.Value104;
15565 present_qSetBitVal(state,Value104_Present_GetBit(state),Value104_PresentQ(parent));
15566 Value104_SetAssigned(state);
15567 lib_fast::InsertPmap(buf,index,pmap);
15568}
15569
15570// --- fasttest.U32IncrNull..FastDecode
15571bool fasttest::U32IncrNull_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32IncrNull& parent) {
15572 bool ok = true;
15573 // Value104 unsigned increment optional
15574 if (ok) {
15575 bool prs = lib_fast::GetPmapBit(pmap,1);
15576 if (prs) {
15577 prs = !lib_fast::DecodeNull(from);
15578 if (prs) {
15579 ok = lib_fast::DecodeUnsigned(from,parent.Value104,true);
15580 if (!ok) {
15581 state.error << "fasttest.U32IncrNull.Value104: bad Unsigned" << eol;
15582 }
15583 }
15584 } else if (Value104_AssignedQ(state)) {
15585 parent.Value104 = state.Value104 + 1;
15586 prs = Value104_PresentQ(state);
15587 } else {
15588 prs = false;
15589 }
15590 pmask_qSetBitVal(parent,Value104_Present_GetBit(parent),prs);
15591 Value104_SetAssigned(state);
15592 present_qSetBitVal(state,Value104_Present_GetBit(state),prs);
15593 state.Value104 = parent.Value104;
15594 }
15595 return ok;
15596}
15597
15598// --- fasttest.U32IncrNull..FixEncode
15599void fasttest::U32IncrNull_FixEncode(cstring& buf, fasttest::U32IncrNull& parent, char soh) {
15600 if (Value104_PresentQ(parent)) {
15601 buf << "1=" << parent.Value104 << soh;
15602 }
15603}
15604
15605// --- fasttest.U32IncrOpt.base.CopyOut
15606// Copy fields out of row
15607void fasttest::parent_CopyOut(fasttest::U32IncrOpt &row, fasttest::TemplateHeader &out) {
15608 // length: field value is computed
15609 // id: field value is computed
15610 (void)row;//only to avoid -Wunused-parameter
15611 (void)out;//only to avoid -Wunused-parameter
15612}
15613
15614// --- fasttest.U32IncrOpt.Value103.ReadStrptrMaybe
15615inline static bool fasttest::Value103_ReadStrptrMaybe(fasttest::U32IncrOpt &parent, algo::strptr in_str) {
15616 bool retval = true;
15617 u32 Value103_tmp;
15618 retval = u32_ReadStrptrMaybe(Value103_tmp, in_str);
15619 if (retval) {
15620 Value103_Set(parent, Value103_tmp);
15621 }
15622 return retval;
15623}
15624
15625// --- fasttest.U32IncrOpt.pmask_bitcurs.Next
15626// proceed to next item
15627void fasttest::U32IncrOpt_pmask_bitcurs_Next(U32IncrOpt_pmask_bitcurs &curs) {
15628 ++curs.bit;
15629 int index = curs.bit / 32;
15630 int offset = curs.bit % 32;
15631 for (; index < curs.n_elems; ++index, offset = 0) {
15632 u64 rest = curs.elems[index] >> offset;
15633 if (rest) {
15634 offset += algo::u64_BitScanForward(rest);
15635 break;
15636 }
15637 }
15638 curs.bit = index * 32 + offset;
15639}
15640
15641// --- fasttest.U32IncrOpt..ReadFieldMaybe
15642bool fasttest::U32IncrOpt_ReadFieldMaybe(fasttest::U32IncrOpt& parent, algo::strptr field, algo::strptr strval) {
15643 bool retval = true;
15644 fasttest::FieldId field_id;
15645 (void)value_SetStrptrMaybe(field_id,field);
15646 switch(field_id) {
15647 case fasttest_FieldId_base: {
15648 retval = false;
15649 break;
15650 }
15651 case fasttest_FieldId_length: {
15652 retval = false;
15653 break;
15654 }
15655 case fasttest_FieldId_id: {
15656 retval = false;
15657 break;
15658 }
15659 case fasttest_FieldId_pmask: {
15660 retval = false;
15661 break;
15662 }
15663 case fasttest_FieldId_Value103: {
15664 retval = Value103_ReadStrptrMaybe(parent, strval);
15665 if (retval) {
15666 pmask_qSetBit(parent, 0);
15667 }
15668 break;
15669 }
15670 default: break;
15671 }
15672 if (!retval) {
15673 algo_lib::AppendErrtext("attr",field);
15674 }
15675 return retval;
15676}
15677
15678// --- fasttest.U32IncrOpt..ReadStrptrMaybe
15679// Read fields of fasttest::U32IncrOpt from an ascii string.
15680// The format of the string is an ssim Tuple
15681bool fasttest::U32IncrOpt_ReadStrptrMaybe(fasttest::U32IncrOpt &parent, algo::strptr in_str) {
15682 bool retval = true;
15683 retval = algo::StripTypeTag(in_str, "fasttest.U32IncrOpt");
15684 ind_beg(algo::Attr_curs, attr, in_str) {
15685 retval = retval && U32IncrOpt_ReadFieldMaybe(parent, attr.name, attr.value);
15686 }ind_end;
15687 return retval;
15688}
15689
15690// --- fasttest.U32IncrOpt..Print
15691// print string representation of ROW to string STR
15692// cfmt:fasttest.U32IncrOpt.String printfmt:Tuple
15693void fasttest::U32IncrOpt_Print(fasttest::U32IncrOpt& row, algo::cstring& str) {
15694 algo::tempstr temp;
15695 str << "fasttest.U32IncrOpt";
15696
15697 if (Value103_PresentQ(row)) {
15698 u32_Print(row.Value103, temp);
15699 PrintAttrSpaceReset(str,"Value103", temp);
15700 }
15701}
15702
15703// --- fasttest.U32IncrOpt..FastEncode
15704void fasttest::U32IncrOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32IncrOpt& parent) {
15705 int index = ary_N(buf);
15706 u64 pmap(0);
15707 if (!tid_AssignedQ(state) || parent.id != state.tid) {
15708 lib_fast::EncodeUnsigned(buf,parent.id,false);
15709 lib_fast::SetPmapBit(pmap,0);
15710 }
15711 tid_SetAssigned(state);
15712 state.tid = parent.id;
15713 // Value103 unsigned increment optional
15714 if (Value103_PresentQ(parent)) {
15715 if (Value103_AssignedQ(state)) {
15716 if (!Value103_PresentQ(state) || parent.Value103 != state.Value103 + 1) {
15717 lib_fast::EncodeUnsigned(buf,parent.Value103,true);
15718 lib_fast::SetPmapBit(pmap,1);
15719 }
15720 } else {
15721 if (parent.Value103 != 103) {
15722 lib_fast::EncodeUnsigned(buf,parent.Value103,true);
15723 lib_fast::SetPmapBit(pmap,1);
15724 }
15725 }
15726 } else {
15727 if (!Value103_AssignedQ(state) || Value103_PresentQ(state)) {
15728 lib_fast::EncodeNull(buf);
15729 lib_fast::SetPmapBit(pmap,1);
15730 }
15731 }
15732 state.Value103 = parent.Value103;
15733 present_qSetBitVal(state,Value103_Present_GetBit(state),Value103_PresentQ(parent));
15734 Value103_SetAssigned(state);
15735 lib_fast::InsertPmap(buf,index,pmap);
15736}
15737
15738// --- fasttest.U32IncrOpt..FastDecode
15739bool fasttest::U32IncrOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32IncrOpt& parent) {
15740 bool ok = true;
15741 // Value103 unsigned increment optional
15742 if (ok) {
15743 bool prs = lib_fast::GetPmapBit(pmap,1);
15744 if (prs) {
15745 prs = !lib_fast::DecodeNull(from);
15746 if (prs) {
15747 ok = lib_fast::DecodeUnsigned(from,parent.Value103,true);
15748 if (!ok) {
15749 state.error << "fasttest.U32IncrOpt.Value103: bad Unsigned" << eol;
15750 }
15751 }
15752 } else if (Value103_AssignedQ(state)) {
15753 parent.Value103 = state.Value103 + 1;
15754 prs = Value103_PresentQ(state);
15755 } else {
15756 parent.Value103 = 103;
15757 prs = true;
15758 }
15759 pmask_qSetBitVal(parent,Value103_Present_GetBit(parent),prs);
15760 Value103_SetAssigned(state);
15761 present_qSetBitVal(state,Value103_Present_GetBit(state),prs);
15762 state.Value103 = parent.Value103;
15763 }
15764 return ok;
15765}
15766
15767// --- fasttest.U32IncrOpt..FixEncode
15768void fasttest::U32IncrOpt_FixEncode(cstring& buf, fasttest::U32IncrOpt& parent, char soh) {
15769 if (Value103_PresentQ(parent)) {
15770 buf << "1=" << parent.Value103 << soh;
15771 }
15772}
15773
15774// --- fasttest.U32None.base.CopyOut
15775// Copy fields out of row
15776void fasttest::parent_CopyOut(fasttest::U32None &row, fasttest::TemplateHeader &out) {
15777 // length: field value is computed
15778 // id: field value is computed
15779 (void)row;//only to avoid -Wunused-parameter
15780 (void)out;//only to avoid -Wunused-parameter
15781}
15782
15783// --- fasttest.U32None..ReadFieldMaybe
15784bool fasttest::U32None_ReadFieldMaybe(fasttest::U32None& parent, algo::strptr field, algo::strptr strval) {
15785 bool retval = true;
15786 fasttest::FieldId field_id;
15787 (void)value_SetStrptrMaybe(field_id,field);
15788 switch(field_id) {
15789 case fasttest_FieldId_base: {
15790 retval = false;
15791 break;
15792 }
15793 case fasttest_FieldId_length: {
15794 retval = false;
15795 break;
15796 }
15797 case fasttest_FieldId_id: {
15798 retval = false;
15799 break;
15800 }
15801 case fasttest_FieldId_Value: {
15802 retval = u32_ReadStrptrMaybe(parent.Value, strval);
15803 break;
15804 }
15805 default: break;
15806 }
15807 if (!retval) {
15808 algo_lib::AppendErrtext("attr",field);
15809 }
15810 return retval;
15811}
15812
15813// --- fasttest.U32None..ReadStrptrMaybe
15814// Read fields of fasttest::U32None from an ascii string.
15815// The format of the string is an ssim Tuple
15816bool fasttest::U32None_ReadStrptrMaybe(fasttest::U32None &parent, algo::strptr in_str) {
15817 bool retval = true;
15818 retval = algo::StripTypeTag(in_str, "fasttest.U32None");
15819 ind_beg(algo::Attr_curs, attr, in_str) {
15820 retval = retval && U32None_ReadFieldMaybe(parent, attr.name, attr.value);
15821 }ind_end;
15822 return retval;
15823}
15824
15825// --- fasttest.U32None..Print
15826// print string representation of ROW to string STR
15827// cfmt:fasttest.U32None.String printfmt:Tuple
15828void fasttest::U32None_Print(fasttest::U32None& row, algo::cstring& str) {
15829 algo::tempstr temp;
15830 str << "fasttest.U32None";
15831
15832 u32_Print(row.Value, temp);
15833 PrintAttrSpaceReset(str,"Value", temp);
15834}
15835
15836// --- fasttest.U32None..FastEncode
15837void fasttest::U32None_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32None& parent) {
15838 int index = ary_N(buf);
15839 u64 pmap(0);
15840 if (!tid_AssignedQ(state) || parent.id != state.tid) {
15841 lib_fast::EncodeUnsigned(buf,parent.id,false);
15842 lib_fast::SetPmapBit(pmap,0);
15843 }
15844 tid_SetAssigned(state);
15845 state.tid = parent.id;
15846 // Value unsigned none mandatory
15847 lib_fast::EncodeUnsigned(buf,parent.Value,false);
15848 lib_fast::InsertPmap(buf,index,pmap);
15849}
15850
15851// --- fasttest.U32None..FastDecode
15852bool fasttest::U32None_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32None& parent) {
15853 bool ok = true;
15854 // Value unsigned none mandatory
15855 if (ok) {
15856 ok = lib_fast::DecodeUnsigned(from,parent.Value,false);
15857 if (!ok) {
15858 state.error << "fasttest.U32None.Value: bad Unsigned" << eol;
15859 }
15860 }
15861 (void)pmap;//only to avoid -Wunused-parameter
15862 return ok;
15863}
15864
15865// --- fasttest.U32None..FixEncode
15866void fasttest::U32None_FixEncode(cstring& buf, fasttest::U32None& parent, char soh) {
15867 buf << "1=" << parent.Value << soh;
15868}
15869
15870// --- fasttest.U32NoneOpt.base.CopyOut
15871// Copy fields out of row
15872void fasttest::parent_CopyOut(fasttest::U32NoneOpt &row, fasttest::TemplateHeader &out) {
15873 // length: field value is computed
15874 // id: field value is computed
15875 (void)row;//only to avoid -Wunused-parameter
15876 (void)out;//only to avoid -Wunused-parameter
15877}
15878
15879// --- fasttest.U32NoneOpt.Value.ReadStrptrMaybe
15880inline static bool fasttest::Value_ReadStrptrMaybe(fasttest::U32NoneOpt &parent, algo::strptr in_str) {
15881 bool retval = true;
15882 u32 Value_tmp;
15883 retval = u32_ReadStrptrMaybe(Value_tmp, in_str);
15884 if (retval) {
15885 Value_Set(parent, Value_tmp);
15886 }
15887 return retval;
15888}
15889
15890// --- fasttest.U32NoneOpt.pmask_bitcurs.Next
15891// proceed to next item
15892void fasttest::U32NoneOpt_pmask_bitcurs_Next(U32NoneOpt_pmask_bitcurs &curs) {
15893 ++curs.bit;
15894 int index = curs.bit / 32;
15895 int offset = curs.bit % 32;
15896 for (; index < curs.n_elems; ++index, offset = 0) {
15897 u64 rest = curs.elems[index] >> offset;
15898 if (rest) {
15899 offset += algo::u64_BitScanForward(rest);
15900 break;
15901 }
15902 }
15903 curs.bit = index * 32 + offset;
15904}
15905
15906// --- fasttest.U32NoneOpt..ReadFieldMaybe
15907bool fasttest::U32NoneOpt_ReadFieldMaybe(fasttest::U32NoneOpt& parent, algo::strptr field, algo::strptr strval) {
15908 bool retval = true;
15909 fasttest::FieldId field_id;
15910 (void)value_SetStrptrMaybe(field_id,field);
15911 switch(field_id) {
15912 case fasttest_FieldId_base: {
15913 retval = false;
15914 break;
15915 }
15916 case fasttest_FieldId_length: {
15917 retval = false;
15918 break;
15919 }
15920 case fasttest_FieldId_id: {
15921 retval = false;
15922 break;
15923 }
15924 case fasttest_FieldId_pmask: {
15925 retval = false;
15926 break;
15927 }
15928 case fasttest_FieldId_Value: {
15929 retval = Value_ReadStrptrMaybe(parent, strval);
15930 if (retval) {
15931 pmask_qSetBit(parent, 0);
15932 }
15933 break;
15934 }
15935 default: break;
15936 }
15937 if (!retval) {
15938 algo_lib::AppendErrtext("attr",field);
15939 }
15940 return retval;
15941}
15942
15943// --- fasttest.U32NoneOpt..ReadStrptrMaybe
15944// Read fields of fasttest::U32NoneOpt from an ascii string.
15945// The format of the string is an ssim Tuple
15946bool fasttest::U32NoneOpt_ReadStrptrMaybe(fasttest::U32NoneOpt &parent, algo::strptr in_str) {
15947 bool retval = true;
15948 retval = algo::StripTypeTag(in_str, "fasttest.U32NoneOpt");
15949 ind_beg(algo::Attr_curs, attr, in_str) {
15950 retval = retval && U32NoneOpt_ReadFieldMaybe(parent, attr.name, attr.value);
15951 }ind_end;
15952 return retval;
15953}
15954
15955// --- fasttest.U32NoneOpt..Print
15956// print string representation of ROW to string STR
15957// cfmt:fasttest.U32NoneOpt.String printfmt:Tuple
15958void fasttest::U32NoneOpt_Print(fasttest::U32NoneOpt& row, algo::cstring& str) {
15959 algo::tempstr temp;
15960 str << "fasttest.U32NoneOpt";
15961
15962 if (Value_PresentQ(row)) {
15963 u32_Print(row.Value, temp);
15964 PrintAttrSpaceReset(str,"Value", temp);
15965 }
15966}
15967
15968// --- fasttest.U32NoneOpt..FastEncode
15969void fasttest::U32NoneOpt_FastEncode(algo::ByteAry& buf, FastState& state, fasttest::U32NoneOpt& parent) {
15970 int index = ary_N(buf);
15971 u64 pmap(0);
15972 if (!tid_AssignedQ(state) || parent.id != state.tid) {
15973 lib_fast::EncodeUnsigned(buf,parent.id,false);
15974 lib_fast::SetPmapBit(pmap,0);
15975 }
15976 tid_SetAssigned(state);
15977 state.tid = parent.id;
15978 // Value unsigned none optional
15979 if (Value_PresentQ(parent)) {
15980 lib_fast::EncodeUnsigned(buf,parent.Value,true);
15981 } else {
15982 lib_fast::EncodeNull(buf);
15983 }
15984 lib_fast::InsertPmap(buf,index,pmap);
15985}
15986
15987// --- fasttest.U32NoneOpt..FastDecode
15988bool fasttest::U32NoneOpt_FastDecode(algo::memptr& from, u64 pmap, FastState& state, fasttest::U32NoneOpt& parent) {
15989 bool ok = true;
15990 // Value unsigned none optional
15991 if (ok) {
15992 bool prs = !lib_fast::DecodeNull(from);
15993 if (prs) {
15994 ok = lib_fast::DecodeUnsigned(from,parent.Value,true);
15995 if (!ok) {
15996 state.error << "fasttest.U32NoneOpt.Value: bad Unsigned" << eol;
15997 }
15998 }
15999 pmask_qSetBitVal(parent,Value_Present_GetBit(parent),prs);
16000 }
16001 (void)pmap;//only to avoid -Wunused-parameter
16002 return ok;
16003}
16004
16005// --- fasttest.U32NoneOpt..FixEncode
16006void fasttest::U32NoneOpt_FixEncode(cstring& buf, fasttest::U32NoneOpt& parent, char soh) {
16007 if (Value_PresentQ(parent)) {
16008 buf << "1=" << parent.Value << soh;
16009 }
16010}
16011
16012// --- fasttest...SizeCheck
16013inline static void fasttest::SizeCheck() {
16014}
16015
16016// --- fasttest...StaticCheck
16017void fasttest::StaticCheck() {
16018 // check that bitfield fits width
16019 algo_assert(sizeof(((fasttest::SampleSet*)0)->value)*8 >= 3);
16020 algo_assert(_offset_of(fasttest::FieldId, value) + sizeof(((fasttest::FieldId*)0)->value) == sizeof(fasttest::FieldId));
16021 algo_assert(_offset_of(fasttest::TemplateHeaderMsgsCase, value) + sizeof(((fasttest::TemplateHeaderMsgsCase*)0)->value) == sizeof(fasttest::TemplateHeaderMsgsCase));
16022 algo_assert(_offset_of(fasttest::TemplateHeader_curs, msglen) + sizeof(((fasttest::TemplateHeader_curs*)0)->msglen) == sizeof(fasttest::TemplateHeader_curs));
16023}
16024
16025// --- fasttest.TemplateHeaderMsgs..FastEncode
16026void fasttest::TemplateHeaderMsgs_FastEncode(algo::ByteAry &buf, FastState &state, fasttest::TemplateHeader &header)
16027 {
16028 switch (header.id) {
16029 case 23:
16030 fasttest::BVConst_FastEncode(buf,state,(fasttest::BVConst&)header);
16031 break;
16032 case 24:
16033 fasttest::BVConstOpt_FastEncode(buf,state,(fasttest::BVConstOpt&)header);
16034 break;
16035 case 58:
16036 fasttest::BVCopy_FastEncode(buf,state,(fasttest::BVCopy&)header);
16037 break;
16038 case 60:
16039 fasttest::BVCopyNull_FastEncode(buf,state,(fasttest::BVCopyNull&)header);
16040 break;
16041 case 59:
16042 fasttest::BVCopyOpt_FastEncode(buf,state,(fasttest::BVCopyOpt&)header);
16043 break;
16044 case 42:
16045 fasttest::BVDflt_FastEncode(buf,state,(fasttest::BVDflt&)header);
16046 break;
16047 case 44:
16048 fasttest::BVDfltNull_FastEncode(buf,state,(fasttest::BVDfltNull&)header);
16049 break;
16050 case 43:
16051 fasttest::BVDfltOpt_FastEncode(buf,state,(fasttest::BVDfltOpt&)header);
16052 break;
16053 case 7:
16054 fasttest::BVNone_FastEncode(buf,state,(fasttest::BVNone&)header);
16055 break;
16056 case 8:
16057 fasttest::BVNoneOpt_FastEncode(buf,state,(fasttest::BVNoneOpt&)header);
16058 break;
16059 case 115:
16060 fasttest::GroupSgmOpt_FastEncode(buf,state,(fasttest::GroupSgmOpt&)header);
16061 break;
16062 case 113:
16063 fasttest::GroupTrv_FastEncode(buf,state,(fasttest::GroupTrv&)header);
16064 break;
16065 case 114:
16066 fasttest::GroupTrvOpt_FastEncode(buf,state,(fasttest::GroupTrvOpt&)header);
16067 break;
16068 case 17:
16069 fasttest::I32Const_FastEncode(buf,state,(fasttest::I32Const&)header);
16070 break;
16071 case 18:
16072 fasttest::I32ConstOpt_FastEncode(buf,state,(fasttest::I32ConstOpt&)header);
16073 break;
16074 case 49:
16075 fasttest::I32Copy_FastEncode(buf,state,(fasttest::I32Copy&)header);
16076 break;
16077 case 51:
16078 fasttest::I32CopyNull_FastEncode(buf,state,(fasttest::I32CopyNull&)header);
16079 break;
16080 case 50:
16081 fasttest::I32CopyOpt_FastEncode(buf,state,(fasttest::I32CopyOpt&)header);
16082 break;
16083 case 65:
16084 fasttest::I32Delta_FastEncode(buf,state,(fasttest::I32Delta&)header);
16085 break;
16086 case 66:
16087 fasttest::I32DeltaImpl_FastEncode(buf,state,(fasttest::I32DeltaImpl&)header);
16088 break;
16089 case 68:
16090 fasttest::I32DeltaNull_FastEncode(buf,state,(fasttest::I32DeltaNull&)header);
16091 break;
16092 case 67:
16093 fasttest::I32DeltaOpt_FastEncode(buf,state,(fasttest::I32DeltaOpt&)header);
16094 break;
16095 case 33:
16096 fasttest::I32Dflt_FastEncode(buf,state,(fasttest::I32Dflt&)header);
16097 break;
16098 case 35:
16099 fasttest::I32DfltNull_FastEncode(buf,state,(fasttest::I32DfltNull&)header);
16100 break;
16101 case 34:
16102 fasttest::I32DfltOpt_FastEncode(buf,state,(fasttest::I32DfltOpt&)header);
16103 break;
16104 case 97:
16105 fasttest::I32Incr_FastEncode(buf,state,(fasttest::I32Incr&)header);
16106 break;
16107 case 98:
16108 fasttest::I32IncrNV_FastEncode(buf,state,(fasttest::I32IncrNV&)header);
16109 break;
16110 case 100:
16111 fasttest::I32IncrNull_FastEncode(buf,state,(fasttest::I32IncrNull&)header);
16112 break;
16113 case 99:
16114 fasttest::I32IncrOpt_FastEncode(buf,state,(fasttest::I32IncrOpt&)header);
16115 break;
16116 case 1:
16117 fasttest::I32None_FastEncode(buf,state,(fasttest::I32None&)header);
16118 break;
16119 case 2:
16120 fasttest::I32NoneOpt_FastEncode(buf,state,(fasttest::I32NoneOpt&)header);
16121 break;
16122 case 151:
16123 fasttest::MsgPmap_FastEncode(buf,state,(fasttest::MsgPmap&)header);
16124 break;
16125 case 120:
16126 fasttest::Reset_FastEncode(buf,state,(fasttest::Reset&)header);
16127 state.assigned = 0;
16128 state.present = 0;
16129 break;
16130 case 145:
16131 fasttest::SampleEnumConst_FastEncode(buf,state,(fasttest::SampleEnumConst&)header);
16132 break;
16133 case 147:
16134 fasttest::SampleEnumCopy_FastEncode(buf,state,(fasttest::SampleEnumCopy&)header);
16135 break;
16136 case 146:
16137 fasttest::SampleEnumDefault_FastEncode(buf,state,(fasttest::SampleEnumDefault&)header);
16138 break;
16139 case 148:
16140 fasttest::SampleSetConst_FastEncode(buf,state,(fasttest::SampleSetConst&)header);
16141 break;
16142 case 150:
16143 fasttest::SampleSetCopy_FastEncode(buf,state,(fasttest::SampleSetCopy&)header);
16144 break;
16145 case 149:
16146 fasttest::SampleSetDefault_FastEncode(buf,state,(fasttest::SampleSetDefault&)header);
16147 break;
16148 case 25:
16149 fasttest::SclConst_FastEncode(buf,state,(fasttest::SclConst&)header);
16150 break;
16151 case 26:
16152 fasttest::SclConstOpt_FastEncode(buf,state,(fasttest::SclConstOpt&)header);
16153 break;
16154 case 61:
16155 fasttest::SclCopy_FastEncode(buf,state,(fasttest::SclCopy&)header);
16156 break;
16157 case 63:
16158 fasttest::SclCopyNull_FastEncode(buf,state,(fasttest::SclCopyNull&)header);
16159 break;
16160 case 62:
16161 fasttest::SclCopyOpt_FastEncode(buf,state,(fasttest::SclCopyOpt&)header);
16162 break;
16163 case 81:
16164 fasttest::SclDelta_FastEncode(buf,state,(fasttest::SclDelta&)header);
16165 break;
16166 case 82:
16167 fasttest::SclDeltaImpl_FastEncode(buf,state,(fasttest::SclDeltaImpl&)header);
16168 break;
16169 case 84:
16170 fasttest::SclDeltaNull_FastEncode(buf,state,(fasttest::SclDeltaNull&)header);
16171 break;
16172 case 83:
16173 fasttest::SclDeltaOpt_FastEncode(buf,state,(fasttest::SclDeltaOpt&)header);
16174 break;
16175 case 45:
16176 fasttest::SclDflt_FastEncode(buf,state,(fasttest::SclDflt&)header);
16177 break;
16178 case 47:
16179 fasttest::SclDfltNull_FastEncode(buf,state,(fasttest::SclDfltNull&)header);
16180 break;
16181 case 46:
16182 fasttest::SclDfltOpt_FastEncode(buf,state,(fasttest::SclDfltOpt&)header);
16183 break;
16184 case 9:
16185 fasttest::SclNone_FastEncode(buf,state,(fasttest::SclNone&)header);
16186 break;
16187 case 10:
16188 fasttest::SclNoneOpt_FastEncode(buf,state,(fasttest::SclNoneOpt&)header);
16189 break;
16190 case 135:
16191 fasttest::SeqOrder_FastEncode(buf,state,(fasttest::SeqOrder&)header);
16192 break;
16193 case 118:
16194 fasttest::SeqSgmOpt_FastEncode(buf,state,(fasttest::SeqSgmOpt&)header);
16195 break;
16196 case 116:
16197 fasttest::SeqTrv_FastEncode(buf,state,(fasttest::SeqTrv&)header);
16198 break;
16199 case 131:
16200 fasttest::SeqTrvLenConst_FastEncode(buf,state,(fasttest::SeqTrvLenConst&)header);
16201 break;
16202 case 132:
16203 fasttest::SeqTrvLenConstOpt_FastEncode(buf,state,(fasttest::SeqTrvLenConstOpt&)header);
16204 break;
16205 case 133:
16206 fasttest::SeqTrvLenDflt_FastEncode(buf,state,(fasttest::SeqTrvLenDflt&)header);
16207 break;
16208 case 134:
16209 fasttest::SeqTrvLenDfltOpt_FastEncode(buf,state,(fasttest::SeqTrvLenDfltOpt&)header);
16210 break;
16211 case 129:
16212 fasttest::SeqTrvLenNone_FastEncode(buf,state,(fasttest::SeqTrvLenNone&)header);
16213 break;
16214 case 130:
16215 fasttest::SeqTrvLenNoneOpt_FastEncode(buf,state,(fasttest::SeqTrvLenNoneOpt&)header);
16216 break;
16217 case 117:
16218 fasttest::SeqTrvOpt_FastEncode(buf,state,(fasttest::SeqTrvOpt&)header);
16219 break;
16220 case 21:
16221 fasttest::StrConst_FastEncode(buf,state,(fasttest::StrConst&)header);
16222 break;
16223 case 22:
16224 fasttest::StrConstOpt_FastEncode(buf,state,(fasttest::StrConstOpt&)header);
16225 break;
16226 case 55:
16227 fasttest::StrCopy_FastEncode(buf,state,(fasttest::StrCopy&)header);
16228 break;
16229 case 57:
16230 fasttest::StrCopyNull_FastEncode(buf,state,(fasttest::StrCopyNull&)header);
16231 break;
16232 case 56:
16233 fasttest::StrCopyOpt_FastEncode(buf,state,(fasttest::StrCopyOpt&)header);
16234 break;
16235 case 39:
16236 fasttest::StrDflt_FastEncode(buf,state,(fasttest::StrDflt&)header);
16237 break;
16238 case 41:
16239 fasttest::StrDfltNull_FastEncode(buf,state,(fasttest::StrDfltNull&)header);
16240 break;
16241 case 40:
16242 fasttest::StrDfltOpt_FastEncode(buf,state,(fasttest::StrDfltOpt&)header);
16243 break;
16244 case 5:
16245 fasttest::StrNone_FastEncode(buf,state,(fasttest::StrNone&)header);
16246 break;
16247 case 6:
16248 fasttest::StrNoneOpt_FastEncode(buf,state,(fasttest::StrNoneOpt&)header);
16249 break;
16250 case 19:
16251 fasttest::U32Const_FastEncode(buf,state,(fasttest::U32Const&)header);
16252 break;
16253 case 20:
16254 fasttest::U32ConstOpt_FastEncode(buf,state,(fasttest::U32ConstOpt&)header);
16255 break;
16256 case 52:
16257 fasttest::U32Copy_FastEncode(buf,state,(fasttest::U32Copy&)header);
16258 break;
16259 case 54:
16260 fasttest::U32CopyNull_FastEncode(buf,state,(fasttest::U32CopyNull&)header);
16261 break;
16262 case 53:
16263 fasttest::U32CopyOpt_FastEncode(buf,state,(fasttest::U32CopyOpt&)header);
16264 break;
16265 case 69:
16266 fasttest::U32Delta_FastEncode(buf,state,(fasttest::U32Delta&)header);
16267 break;
16268 case 70:
16269 fasttest::U32DeltaImpl_FastEncode(buf,state,(fasttest::U32DeltaImpl&)header);
16270 break;
16271 case 72:
16272 fasttest::U32DeltaNull_FastEncode(buf,state,(fasttest::U32DeltaNull&)header);
16273 break;
16274 case 71:
16275 fasttest::U32DeltaOpt_FastEncode(buf,state,(fasttest::U32DeltaOpt&)header);
16276 break;
16277 case 36:
16278 fasttest::U32Dflt_FastEncode(buf,state,(fasttest::U32Dflt&)header);
16279 break;
16280 case 38:
16281 fasttest::U32DfltNull_FastEncode(buf,state,(fasttest::U32DfltNull&)header);
16282 break;
16283 case 37:
16284 fasttest::U32DfltOpt_FastEncode(buf,state,(fasttest::U32DfltOpt&)header);
16285 break;
16286 case 101:
16287 fasttest::U32Incr_FastEncode(buf,state,(fasttest::U32Incr&)header);
16288 break;
16289 case 102:
16290 fasttest::U32IncrNV_FastEncode(buf,state,(fasttest::U32IncrNV&)header);
16291 break;
16292 case 104:
16293 fasttest::U32IncrNull_FastEncode(buf,state,(fasttest::U32IncrNull&)header);
16294 break;
16295 case 103:
16296 fasttest::U32IncrOpt_FastEncode(buf,state,(fasttest::U32IncrOpt&)header);
16297 break;
16298 case 3:
16299 fasttest::U32None_FastEncode(buf,state,(fasttest::U32None&)header);
16300 break;
16301 case 4:
16302 fasttest::U32NoneOpt_FastEncode(buf,state,(fasttest::U32NoneOpt&)header);
16303 break;
16304 }
16305}
16306
16307// --- fasttest.TemplateHeaderMsgs..FastDecode
16308fasttest::TemplateHeader * fasttest::TemplateHeaderMsgs_FastDecode(algo::memptr &from, FastState &state,algo::ByteAry &buf) {
16309 int index = ary_N(buf);
16310 TemplateHeader *ret(NULL);
16311 u64 pmap;
16312 u32 tid(0);
16313 bool ok = lib_fast::DecodePmap(from,pmap);
16314 if (!ok) {
16315 state.error << "fasttest.TemplateHeader: bad pmap" << eol;
16316 }
16317 if (ok) {
16318 bool prs = lib_fast::GetPmapBit(pmap,0);
16319 if (prs) {
16320 ok = lib_fast::DecodeUnsigned(from,tid,false);
16321 if (!ok) {
16322 state.error << "fasttest.TemplateHeader.id: bad Unsigned" << eol;
16323 }
16324 } else if (tid_AssignedQ(state)) {
16325 tid = state.tid;
16326 } else {
16327 ok = false;
16328 state.error << "fasttest.TemplateHeader.id: copy operator: previous value unassigned" << eol;
16329 }
16330 tid_SetAssigned(state);
16331 state.tid = tid;
16332 }
16333 if (ok) {
16334 switch (tid) {
16335 case 23:
16336 {
16337 fasttest::BVConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVConst;
16338 ok = BVConst_FastDecode(from,pmap,state,msg);
16339 ret = ok ? &Castbase(*(fasttest::BVConst*)(buf.ary_elems+index)) : NULL;
16340 }
16341 break;
16342 case 24:
16343 {
16344 fasttest::BVConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVConstOpt;
16345 ok = BVConstOpt_FastDecode(from,pmap,state,msg);
16346 ret = ok ? &Castbase(*(fasttest::BVConstOpt*)(buf.ary_elems+index)) : NULL;
16347 }
16348 break;
16349 case 58:
16350 {
16351 fasttest::BVCopy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVCopy;
16352 ok = BVCopy_FastDecode(from,pmap,state,msg);
16353 ret = ok ? &Castbase(*(fasttest::BVCopy*)(buf.ary_elems+index)) : NULL;
16354 }
16355 break;
16356 case 60:
16357 {
16358 fasttest::BVCopyNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVCopyNull;
16359 ok = BVCopyNull_FastDecode(from,pmap,state,msg);
16360 ret = ok ? &Castbase(*(fasttest::BVCopyNull*)(buf.ary_elems+index)) : NULL;
16361 }
16362 break;
16363 case 59:
16364 {
16365 fasttest::BVCopyOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVCopyOpt;
16366 ok = BVCopyOpt_FastDecode(from,pmap,state,msg);
16367 ret = ok ? &Castbase(*(fasttest::BVCopyOpt*)(buf.ary_elems+index)) : NULL;
16368 }
16369 break;
16370 case 42:
16371 {
16372 fasttest::BVDflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVDflt;
16373 ok = BVDflt_FastDecode(from,pmap,state,msg);
16374 ret = ok ? &Castbase(*(fasttest::BVDflt*)(buf.ary_elems+index)) : NULL;
16375 }
16376 break;
16377 case 44:
16378 {
16379 fasttest::BVDfltNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVDfltNull;
16380 ok = BVDfltNull_FastDecode(from,pmap,state,msg);
16381 ret = ok ? &Castbase(*(fasttest::BVDfltNull*)(buf.ary_elems+index)) : NULL;
16382 }
16383 break;
16384 case 43:
16385 {
16386 fasttest::BVDfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVDfltOpt;
16387 ok = BVDfltOpt_FastDecode(from,pmap,state,msg);
16388 ret = ok ? &Castbase(*(fasttest::BVDfltOpt*)(buf.ary_elems+index)) : NULL;
16389 }
16390 break;
16391 case 7:
16392 {
16393 fasttest::BVNone &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVNone;
16394 ok = BVNone_FastDecode(from,pmap,state,msg);
16395 ret = ok ? &Castbase(*(fasttest::BVNone*)(buf.ary_elems+index)) : NULL;
16396 }
16397 break;
16398 case 8:
16399 {
16400 fasttest::BVNoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::BVNoneOpt;
16401 ok = BVNoneOpt_FastDecode(from,pmap,state,msg);
16402 ret = ok ? &Castbase(*(fasttest::BVNoneOpt*)(buf.ary_elems+index)) : NULL;
16403 }
16404 break;
16405 case 115:
16406 {
16407 fasttest::GroupSgmOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::GroupSgmOpt;
16408 ok = GroupSgmOpt_FastDecode(from,pmap,state,msg);
16409 ret = ok ? &Castbase(*(fasttest::GroupSgmOpt*)(buf.ary_elems+index)) : NULL;
16410 }
16411 break;
16412 case 113:
16413 {
16414 fasttest::GroupTrv &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::GroupTrv;
16415 ok = GroupTrv_FastDecode(from,pmap,state,msg);
16416 ret = ok ? &Castbase(*(fasttest::GroupTrv*)(buf.ary_elems+index)) : NULL;
16417 }
16418 break;
16419 case 114:
16420 {
16421 fasttest::GroupTrvOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::GroupTrvOpt;
16422 ok = GroupTrvOpt_FastDecode(from,pmap,state,msg);
16423 ret = ok ? &Castbase(*(fasttest::GroupTrvOpt*)(buf.ary_elems+index)) : NULL;
16424 }
16425 break;
16426 case 17:
16427 {
16428 fasttest::I32Const &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32Const;
16429 ok = I32Const_FastDecode(from,pmap,state,msg);
16430 ret = ok ? &Castbase(*(fasttest::I32Const*)(buf.ary_elems+index)) : NULL;
16431 }
16432 break;
16433 case 18:
16434 {
16435 fasttest::I32ConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32ConstOpt;
16436 ok = I32ConstOpt_FastDecode(from,pmap,state,msg);
16437 ret = ok ? &Castbase(*(fasttest::I32ConstOpt*)(buf.ary_elems+index)) : NULL;
16438 }
16439 break;
16440 case 49:
16441 {
16442 fasttest::I32Copy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32Copy;
16443 ok = I32Copy_FastDecode(from,pmap,state,msg);
16444 ret = ok ? &Castbase(*(fasttest::I32Copy*)(buf.ary_elems+index)) : NULL;
16445 }
16446 break;
16447 case 51:
16448 {
16449 fasttest::I32CopyNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32CopyNull;
16450 ok = I32CopyNull_FastDecode(from,pmap,state,msg);
16451 ret = ok ? &Castbase(*(fasttest::I32CopyNull*)(buf.ary_elems+index)) : NULL;
16452 }
16453 break;
16454 case 50:
16455 {
16456 fasttest::I32CopyOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32CopyOpt;
16457 ok = I32CopyOpt_FastDecode(from,pmap,state,msg);
16458 ret = ok ? &Castbase(*(fasttest::I32CopyOpt*)(buf.ary_elems+index)) : NULL;
16459 }
16460 break;
16461 case 65:
16462 {
16463 fasttest::I32Delta &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32Delta;
16464 ok = I32Delta_FastDecode(from,pmap,state,msg);
16465 ret = ok ? &Castbase(*(fasttest::I32Delta*)(buf.ary_elems+index)) : NULL;
16466 }
16467 break;
16468 case 66:
16469 {
16470 fasttest::I32DeltaImpl &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32DeltaImpl;
16471 ok = I32DeltaImpl_FastDecode(from,pmap,state,msg);
16472 ret = ok ? &Castbase(*(fasttest::I32DeltaImpl*)(buf.ary_elems+index)) : NULL;
16473 }
16474 break;
16475 case 68:
16476 {
16477 fasttest::I32DeltaNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32DeltaNull;
16478 ok = I32DeltaNull_FastDecode(from,pmap,state,msg);
16479 ret = ok ? &Castbase(*(fasttest::I32DeltaNull*)(buf.ary_elems+index)) : NULL;
16480 }
16481 break;
16482 case 67:
16483 {
16484 fasttest::I32DeltaOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32DeltaOpt;
16485 ok = I32DeltaOpt_FastDecode(from,pmap,state,msg);
16486 ret = ok ? &Castbase(*(fasttest::I32DeltaOpt*)(buf.ary_elems+index)) : NULL;
16487 }
16488 break;
16489 case 33:
16490 {
16491 fasttest::I32Dflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32Dflt;
16492 ok = I32Dflt_FastDecode(from,pmap,state,msg);
16493 ret = ok ? &Castbase(*(fasttest::I32Dflt*)(buf.ary_elems+index)) : NULL;
16494 }
16495 break;
16496 case 35:
16497 {
16498 fasttest::I32DfltNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32DfltNull;
16499 ok = I32DfltNull_FastDecode(from,pmap,state,msg);
16500 ret = ok ? &Castbase(*(fasttest::I32DfltNull*)(buf.ary_elems+index)) : NULL;
16501 }
16502 break;
16503 case 34:
16504 {
16505 fasttest::I32DfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32DfltOpt;
16506 ok = I32DfltOpt_FastDecode(from,pmap,state,msg);
16507 ret = ok ? &Castbase(*(fasttest::I32DfltOpt*)(buf.ary_elems+index)) : NULL;
16508 }
16509 break;
16510 case 97:
16511 {
16512 fasttest::I32Incr &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32Incr;
16513 ok = I32Incr_FastDecode(from,pmap,state,msg);
16514 ret = ok ? &Castbase(*(fasttest::I32Incr*)(buf.ary_elems+index)) : NULL;
16515 }
16516 break;
16517 case 98:
16518 {
16519 fasttest::I32IncrNV &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32IncrNV;
16520 ok = I32IncrNV_FastDecode(from,pmap,state,msg);
16521 ret = ok ? &Castbase(*(fasttest::I32IncrNV*)(buf.ary_elems+index)) : NULL;
16522 }
16523 break;
16524 case 100:
16525 {
16526 fasttest::I32IncrNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32IncrNull;
16527 ok = I32IncrNull_FastDecode(from,pmap,state,msg);
16528 ret = ok ? &Castbase(*(fasttest::I32IncrNull*)(buf.ary_elems+index)) : NULL;
16529 }
16530 break;
16531 case 99:
16532 {
16533 fasttest::I32IncrOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32IncrOpt;
16534 ok = I32IncrOpt_FastDecode(from,pmap,state,msg);
16535 ret = ok ? &Castbase(*(fasttest::I32IncrOpt*)(buf.ary_elems+index)) : NULL;
16536 }
16537 break;
16538 case 1:
16539 {
16540 fasttest::I32None &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32None;
16541 ok = I32None_FastDecode(from,pmap,state,msg);
16542 ret = ok ? &Castbase(*(fasttest::I32None*)(buf.ary_elems+index)) : NULL;
16543 }
16544 break;
16545 case 2:
16546 {
16547 fasttest::I32NoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::I32NoneOpt;
16548 ok = I32NoneOpt_FastDecode(from,pmap,state,msg);
16549 ret = ok ? &Castbase(*(fasttest::I32NoneOpt*)(buf.ary_elems+index)) : NULL;
16550 }
16551 break;
16552 case 151:
16553 {
16554 fasttest::MsgPmap &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::MsgPmap;
16555 ok = MsgPmap_FastDecode(from,pmap,state,msg);
16556 ret = ok ? &Castbase(*(fasttest::MsgPmap*)(buf.ary_elems+index)) : NULL;
16557 }
16558 break;
16559 case 120:
16560 {
16561 state.assigned = 0;
16562 state.present = 0;
16563 fasttest::Reset &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::Reset;
16564 ok = Reset_FastDecode(from,pmap,state,msg);
16565 ret = ok ? &Castbase(*(fasttest::Reset*)(buf.ary_elems+index)) : NULL;
16566 }
16567 break;
16568 case 145:
16569 {
16570 fasttest::SampleEnumConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleEnumConst;
16571 ok = SampleEnumConst_FastDecode(from,pmap,state,msg);
16572 ret = ok ? &Castbase(*(fasttest::SampleEnumConst*)(buf.ary_elems+index)) : NULL;
16573 }
16574 break;
16575 case 147:
16576 {
16577 fasttest::SampleEnumCopy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleEnumCopy;
16578 ok = SampleEnumCopy_FastDecode(from,pmap,state,msg);
16579 ret = ok ? &Castbase(*(fasttest::SampleEnumCopy*)(buf.ary_elems+index)) : NULL;
16580 }
16581 break;
16582 case 146:
16583 {
16584 fasttest::SampleEnumDefault &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleEnumDefault;
16585 ok = SampleEnumDefault_FastDecode(from,pmap,state,msg);
16586 ret = ok ? &Castbase(*(fasttest::SampleEnumDefault*)(buf.ary_elems+index)) : NULL;
16587 }
16588 break;
16589 case 148:
16590 {
16591 fasttest::SampleSetConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleSetConst;
16592 ok = SampleSetConst_FastDecode(from,pmap,state,msg);
16593 ret = ok ? &Castbase(*(fasttest::SampleSetConst*)(buf.ary_elems+index)) : NULL;
16594 }
16595 break;
16596 case 150:
16597 {
16598 fasttest::SampleSetCopy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleSetCopy;
16599 ok = SampleSetCopy_FastDecode(from,pmap,state,msg);
16600 ret = ok ? &Castbase(*(fasttest::SampleSetCopy*)(buf.ary_elems+index)) : NULL;
16601 }
16602 break;
16603 case 149:
16604 {
16605 fasttest::SampleSetDefault &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SampleSetDefault;
16606 ok = SampleSetDefault_FastDecode(from,pmap,state,msg);
16607 ret = ok ? &Castbase(*(fasttest::SampleSetDefault*)(buf.ary_elems+index)) : NULL;
16608 }
16609 break;
16610 case 25:
16611 {
16612 fasttest::SclConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclConst;
16613 ok = SclConst_FastDecode(from,pmap,state,msg);
16614 ret = ok ? &Castbase(*(fasttest::SclConst*)(buf.ary_elems+index)) : NULL;
16615 }
16616 break;
16617 case 26:
16618 {
16619 fasttest::SclConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclConstOpt;
16620 ok = SclConstOpt_FastDecode(from,pmap,state,msg);
16621 ret = ok ? &Castbase(*(fasttest::SclConstOpt*)(buf.ary_elems+index)) : NULL;
16622 }
16623 break;
16624 case 61:
16625 {
16626 fasttest::SclCopy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclCopy;
16627 ok = SclCopy_FastDecode(from,pmap,state,msg);
16628 ret = ok ? &Castbase(*(fasttest::SclCopy*)(buf.ary_elems+index)) : NULL;
16629 }
16630 break;
16631 case 63:
16632 {
16633 fasttest::SclCopyNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclCopyNull;
16634 ok = SclCopyNull_FastDecode(from,pmap,state,msg);
16635 ret = ok ? &Castbase(*(fasttest::SclCopyNull*)(buf.ary_elems+index)) : NULL;
16636 }
16637 break;
16638 case 62:
16639 {
16640 fasttest::SclCopyOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclCopyOpt;
16641 ok = SclCopyOpt_FastDecode(from,pmap,state,msg);
16642 ret = ok ? &Castbase(*(fasttest::SclCopyOpt*)(buf.ary_elems+index)) : NULL;
16643 }
16644 break;
16645 case 81:
16646 {
16647 fasttest::SclDelta &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDelta;
16648 ok = SclDelta_FastDecode(from,pmap,state,msg);
16649 ret = ok ? &Castbase(*(fasttest::SclDelta*)(buf.ary_elems+index)) : NULL;
16650 }
16651 break;
16652 case 82:
16653 {
16654 fasttest::SclDeltaImpl &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDeltaImpl;
16655 ok = SclDeltaImpl_FastDecode(from,pmap,state,msg);
16656 ret = ok ? &Castbase(*(fasttest::SclDeltaImpl*)(buf.ary_elems+index)) : NULL;
16657 }
16658 break;
16659 case 84:
16660 {
16661 fasttest::SclDeltaNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDeltaNull;
16662 ok = SclDeltaNull_FastDecode(from,pmap,state,msg);
16663 ret = ok ? &Castbase(*(fasttest::SclDeltaNull*)(buf.ary_elems+index)) : NULL;
16664 }
16665 break;
16666 case 83:
16667 {
16668 fasttest::SclDeltaOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDeltaOpt;
16669 ok = SclDeltaOpt_FastDecode(from,pmap,state,msg);
16670 ret = ok ? &Castbase(*(fasttest::SclDeltaOpt*)(buf.ary_elems+index)) : NULL;
16671 }
16672 break;
16673 case 45:
16674 {
16675 fasttest::SclDflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDflt;
16676 ok = SclDflt_FastDecode(from,pmap,state,msg);
16677 ret = ok ? &Castbase(*(fasttest::SclDflt*)(buf.ary_elems+index)) : NULL;
16678 }
16679 break;
16680 case 47:
16681 {
16682 fasttest::SclDfltNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDfltNull;
16683 ok = SclDfltNull_FastDecode(from,pmap,state,msg);
16684 ret = ok ? &Castbase(*(fasttest::SclDfltNull*)(buf.ary_elems+index)) : NULL;
16685 }
16686 break;
16687 case 46:
16688 {
16689 fasttest::SclDfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclDfltOpt;
16690 ok = SclDfltOpt_FastDecode(from,pmap,state,msg);
16691 ret = ok ? &Castbase(*(fasttest::SclDfltOpt*)(buf.ary_elems+index)) : NULL;
16692 }
16693 break;
16694 case 9:
16695 {
16696 fasttest::SclNone &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclNone;
16697 ok = SclNone_FastDecode(from,pmap,state,msg);
16698 ret = ok ? &Castbase(*(fasttest::SclNone*)(buf.ary_elems+index)) : NULL;
16699 }
16700 break;
16701 case 10:
16702 {
16703 fasttest::SclNoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SclNoneOpt;
16704 ok = SclNoneOpt_FastDecode(from,pmap,state,msg);
16705 ret = ok ? &Castbase(*(fasttest::SclNoneOpt*)(buf.ary_elems+index)) : NULL;
16706 }
16707 break;
16708 case 135:
16709 {
16710 ary_RemoveAll(lib_fast::_db.varlen);
16711 fasttest::SeqOrder &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqOrder;
16712 ok = SeqOrder_FastDecode(from,pmap,state,msg);
16713 msg.length += ary_N(lib_fast::_db.varlen);
16714 ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16715 ary_RemoveAll(lib_fast::_db.varlen);
16716 ret = ok ? &Castbase(*(fasttest::SeqOrder*)(buf.ary_elems+index)) : NULL;
16717 }
16718 break;
16719 case 118:
16720 {
16721 ary_RemoveAll(lib_fast::_db.varlen);
16722 fasttest::SeqSgmOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqSgmOpt;
16723 ok = SeqSgmOpt_FastDecode(from,pmap,state,msg);
16724 msg.length += ary_N(lib_fast::_db.varlen);
16725 ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16726 ary_RemoveAll(lib_fast::_db.varlen);
16727 ret = ok ? &Castbase(*(fasttest::SeqSgmOpt*)(buf.ary_elems+index)) : NULL;
16728 }
16729 break;
16730 case 116:
16731 {
16732 ary_RemoveAll(lib_fast::_db.varlen);
16733 fasttest::SeqTrv &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrv;
16734 ok = SeqTrv_FastDecode(from,pmap,state,msg);
16735 msg.length += ary_N(lib_fast::_db.varlen);
16736 ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16737 ary_RemoveAll(lib_fast::_db.varlen);
16738 ret = ok ? &Castbase(*(fasttest::SeqTrv*)(buf.ary_elems+index)) : NULL;
16739 }
16740 break;
16741 case 131:
16742 {
16743 fasttest::SeqTrvLenConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenConst;
16744 ok = SeqTrvLenConst_FastDecode(from,pmap,state,msg);
16745 ret = ok ? &Castbase(*(fasttest::SeqTrvLenConst*)(buf.ary_elems+index)) : NULL;
16746 }
16747 break;
16748 case 132:
16749 {
16750 fasttest::SeqTrvLenConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenConstOpt;
16751 ok = SeqTrvLenConstOpt_FastDecode(from,pmap,state,msg);
16752 ret = ok ? &Castbase(*(fasttest::SeqTrvLenConstOpt*)(buf.ary_elems+index)) : NULL;
16753 }
16754 break;
16755 case 133:
16756 {
16757 ary_RemoveAll(lib_fast::_db.varlen);
16758 fasttest::SeqTrvLenDflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenDflt;
16759 ok = SeqTrvLenDflt_FastDecode(from,pmap,state,msg);
16760 msg.length += ary_N(lib_fast::_db.varlen);
16761 ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16762 ary_RemoveAll(lib_fast::_db.varlen);
16763 ret = ok ? &Castbase(*(fasttest::SeqTrvLenDflt*)(buf.ary_elems+index)) : NULL;
16764 }
16765 break;
16766 case 134:
16767 {
16768 ary_RemoveAll(lib_fast::_db.varlen);
16769 fasttest::SeqTrvLenDfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenDfltOpt;
16770 ok = SeqTrvLenDfltOpt_FastDecode(from,pmap,state,msg);
16771 msg.length += ary_N(lib_fast::_db.varlen);
16772 ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16773 ary_RemoveAll(lib_fast::_db.varlen);
16774 ret = ok ? &Castbase(*(fasttest::SeqTrvLenDfltOpt*)(buf.ary_elems+index)) : NULL;
16775 }
16776 break;
16777 case 129:
16778 {
16779 ary_RemoveAll(lib_fast::_db.varlen);
16780 fasttest::SeqTrvLenNone &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenNone;
16781 ok = SeqTrvLenNone_FastDecode(from,pmap,state,msg);
16782 msg.length += ary_N(lib_fast::_db.varlen);
16783 ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16784 ary_RemoveAll(lib_fast::_db.varlen);
16785 ret = ok ? &Castbase(*(fasttest::SeqTrvLenNone*)(buf.ary_elems+index)) : NULL;
16786 }
16787 break;
16788 case 130:
16789 {
16790 ary_RemoveAll(lib_fast::_db.varlen);
16791 fasttest::SeqTrvLenNoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvLenNoneOpt;
16792 ok = SeqTrvLenNoneOpt_FastDecode(from,pmap,state,msg);
16793 msg.length += ary_N(lib_fast::_db.varlen);
16794 ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16795 ary_RemoveAll(lib_fast::_db.varlen);
16796 ret = ok ? &Castbase(*(fasttest::SeqTrvLenNoneOpt*)(buf.ary_elems+index)) : NULL;
16797 }
16798 break;
16799 case 117:
16800 {
16801 ary_RemoveAll(lib_fast::_db.varlen);
16802 fasttest::SeqTrvOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::SeqTrvOpt;
16803 ok = SeqTrvOpt_FastDecode(from,pmap,state,msg);
16804 msg.length += ary_N(lib_fast::_db.varlen);
16805 ary_Addary(buf,ary_Getary(lib_fast::_db.varlen));
16806 ary_RemoveAll(lib_fast::_db.varlen);
16807 ret = ok ? &Castbase(*(fasttest::SeqTrvOpt*)(buf.ary_elems+index)) : NULL;
16808 }
16809 break;
16810 case 21:
16811 {
16812 fasttest::StrConst &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrConst;
16813 ok = StrConst_FastDecode(from,pmap,state,msg);
16814 ret = ok ? &Castbase(*(fasttest::StrConst*)(buf.ary_elems+index)) : NULL;
16815 }
16816 break;
16817 case 22:
16818 {
16819 fasttest::StrConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrConstOpt;
16820 ok = StrConstOpt_FastDecode(from,pmap,state,msg);
16821 ret = ok ? &Castbase(*(fasttest::StrConstOpt*)(buf.ary_elems+index)) : NULL;
16822 }
16823 break;
16824 case 55:
16825 {
16826 fasttest::StrCopy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrCopy;
16827 ok = StrCopy_FastDecode(from,pmap,state,msg);
16828 ret = ok ? &Castbase(*(fasttest::StrCopy*)(buf.ary_elems+index)) : NULL;
16829 }
16830 break;
16831 case 57:
16832 {
16833 fasttest::StrCopyNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrCopyNull;
16834 ok = StrCopyNull_FastDecode(from,pmap,state,msg);
16835 ret = ok ? &Castbase(*(fasttest::StrCopyNull*)(buf.ary_elems+index)) : NULL;
16836 }
16837 break;
16838 case 56:
16839 {
16840 fasttest::StrCopyOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrCopyOpt;
16841 ok = StrCopyOpt_FastDecode(from,pmap,state,msg);
16842 ret = ok ? &Castbase(*(fasttest::StrCopyOpt*)(buf.ary_elems+index)) : NULL;
16843 }
16844 break;
16845 case 39:
16846 {
16847 fasttest::StrDflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrDflt;
16848 ok = StrDflt_FastDecode(from,pmap,state,msg);
16849 ret = ok ? &Castbase(*(fasttest::StrDflt*)(buf.ary_elems+index)) : NULL;
16850 }
16851 break;
16852 case 41:
16853 {
16854 fasttest::StrDfltNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrDfltNull;
16855 ok = StrDfltNull_FastDecode(from,pmap,state,msg);
16856 ret = ok ? &Castbase(*(fasttest::StrDfltNull*)(buf.ary_elems+index)) : NULL;
16857 }
16858 break;
16859 case 40:
16860 {
16861 fasttest::StrDfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrDfltOpt;
16862 ok = StrDfltOpt_FastDecode(from,pmap,state,msg);
16863 ret = ok ? &Castbase(*(fasttest::StrDfltOpt*)(buf.ary_elems+index)) : NULL;
16864 }
16865 break;
16866 case 5:
16867 {
16868 fasttest::StrNone &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrNone;
16869 ok = StrNone_FastDecode(from,pmap,state,msg);
16870 ret = ok ? &Castbase(*(fasttest::StrNone*)(buf.ary_elems+index)) : NULL;
16871 }
16872 break;
16873 case 6:
16874 {
16875 fasttest::StrNoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::StrNoneOpt;
16876 ok = StrNoneOpt_FastDecode(from,pmap,state,msg);
16877 ret = ok ? &Castbase(*(fasttest::StrNoneOpt*)(buf.ary_elems+index)) : NULL;
16878 }
16879 break;
16880 case 19:
16881 {
16882 fasttest::U32Const &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32Const;
16883 ok = U32Const_FastDecode(from,pmap,state,msg);
16884 ret = ok ? &Castbase(*(fasttest::U32Const*)(buf.ary_elems+index)) : NULL;
16885 }
16886 break;
16887 case 20:
16888 {
16889 fasttest::U32ConstOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32ConstOpt;
16890 ok = U32ConstOpt_FastDecode(from,pmap,state,msg);
16891 ret = ok ? &Castbase(*(fasttest::U32ConstOpt*)(buf.ary_elems+index)) : NULL;
16892 }
16893 break;
16894 case 52:
16895 {
16896 fasttest::U32Copy &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32Copy;
16897 ok = U32Copy_FastDecode(from,pmap,state,msg);
16898 ret = ok ? &Castbase(*(fasttest::U32Copy*)(buf.ary_elems+index)) : NULL;
16899 }
16900 break;
16901 case 54:
16902 {
16903 fasttest::U32CopyNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32CopyNull;
16904 ok = U32CopyNull_FastDecode(from,pmap,state,msg);
16905 ret = ok ? &Castbase(*(fasttest::U32CopyNull*)(buf.ary_elems+index)) : NULL;
16906 }
16907 break;
16908 case 53:
16909 {
16910 fasttest::U32CopyOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32CopyOpt;
16911 ok = U32CopyOpt_FastDecode(from,pmap,state,msg);
16912 ret = ok ? &Castbase(*(fasttest::U32CopyOpt*)(buf.ary_elems+index)) : NULL;
16913 }
16914 break;
16915 case 69:
16916 {
16917 fasttest::U32Delta &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32Delta;
16918 ok = U32Delta_FastDecode(from,pmap,state,msg);
16919 ret = ok ? &Castbase(*(fasttest::U32Delta*)(buf.ary_elems+index)) : NULL;
16920 }
16921 break;
16922 case 70:
16923 {
16924 fasttest::U32DeltaImpl &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32DeltaImpl;
16925 ok = U32DeltaImpl_FastDecode(from,pmap,state,msg);
16926 ret = ok ? &Castbase(*(fasttest::U32DeltaImpl*)(buf.ary_elems+index)) : NULL;
16927 }
16928 break;
16929 case 72:
16930 {
16931 fasttest::U32DeltaNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32DeltaNull;
16932 ok = U32DeltaNull_FastDecode(from,pmap,state,msg);
16933 ret = ok ? &Castbase(*(fasttest::U32DeltaNull*)(buf.ary_elems+index)) : NULL;
16934 }
16935 break;
16936 case 71:
16937 {
16938 fasttest::U32DeltaOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32DeltaOpt;
16939 ok = U32DeltaOpt_FastDecode(from,pmap,state,msg);
16940 ret = ok ? &Castbase(*(fasttest::U32DeltaOpt*)(buf.ary_elems+index)) : NULL;
16941 }
16942 break;
16943 case 36:
16944 {
16945 fasttest::U32Dflt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32Dflt;
16946 ok = U32Dflt_FastDecode(from,pmap,state,msg);
16947 ret = ok ? &Castbase(*(fasttest::U32Dflt*)(buf.ary_elems+index)) : NULL;
16948 }
16949 break;
16950 case 38:
16951 {
16952 fasttest::U32DfltNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32DfltNull;
16953 ok = U32DfltNull_FastDecode(from,pmap,state,msg);
16954 ret = ok ? &Castbase(*(fasttest::U32DfltNull*)(buf.ary_elems+index)) : NULL;
16955 }
16956 break;
16957 case 37:
16958 {
16959 fasttest::U32DfltOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32DfltOpt;
16960 ok = U32DfltOpt_FastDecode(from,pmap,state,msg);
16961 ret = ok ? &Castbase(*(fasttest::U32DfltOpt*)(buf.ary_elems+index)) : NULL;
16962 }
16963 break;
16964 case 101:
16965 {
16966 fasttest::U32Incr &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32Incr;
16967 ok = U32Incr_FastDecode(from,pmap,state,msg);
16968 ret = ok ? &Castbase(*(fasttest::U32Incr*)(buf.ary_elems+index)) : NULL;
16969 }
16970 break;
16971 case 102:
16972 {
16973 fasttest::U32IncrNV &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32IncrNV;
16974 ok = U32IncrNV_FastDecode(from,pmap,state,msg);
16975 ret = ok ? &Castbase(*(fasttest::U32IncrNV*)(buf.ary_elems+index)) : NULL;
16976 }
16977 break;
16978 case 104:
16979 {
16980 fasttest::U32IncrNull &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32IncrNull;
16981 ok = U32IncrNull_FastDecode(from,pmap,state,msg);
16982 ret = ok ? &Castbase(*(fasttest::U32IncrNull*)(buf.ary_elems+index)) : NULL;
16983 }
16984 break;
16985 case 103:
16986 {
16987 fasttest::U32IncrOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32IncrOpt;
16988 ok = U32IncrOpt_FastDecode(from,pmap,state,msg);
16989 ret = ok ? &Castbase(*(fasttest::U32IncrOpt*)(buf.ary_elems+index)) : NULL;
16990 }
16991 break;
16992 case 3:
16993 {
16994 fasttest::U32None &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32None;
16995 ok = U32None_FastDecode(from,pmap,state,msg);
16996 ret = ok ? &Castbase(*(fasttest::U32None*)(buf.ary_elems+index)) : NULL;
16997 }
16998 break;
16999 case 4:
17000 {
17001 fasttest::U32NoneOpt &msg = *new(ary_AllocN(buf,sizeof msg).elems) fasttest::U32NoneOpt;
17002 ok = U32NoneOpt_FastDecode(from,pmap,state,msg);
17003 ret = ok ? &Castbase(*(fasttest::U32NoneOpt*)(buf.ary_elems+index)) : NULL;
17004 }
17005 break;
17006 default:
17007 ok = false;
17008 state.error << "fasttest.TemplateHeader.id: unknown template " << tid << eol;
17009 }
17010 }
17011 return ret;
17012}
17013
17014// --- fasttest.TemplateHeaderMsgs..FixEncode
17015void fasttest::TemplateHeaderMsgs_FixEncode(cstring &buf, fasttest::TemplateHeader &header, char soh) {
17016 switch (header.id) {
17017 case 23:
17018 BVConst_FixEncode(buf,*fasttest::BVConst_Castdown(header),soh);
17019 break;
17020 case 24:
17021 BVConstOpt_FixEncode(buf,*fasttest::BVConstOpt_Castdown(header),soh);
17022 break;
17023 case 58:
17024 BVCopy_FixEncode(buf,*fasttest::BVCopy_Castdown(header),soh);
17025 break;
17026 case 60:
17027 BVCopyNull_FixEncode(buf,*fasttest::BVCopyNull_Castdown(header),soh);
17028 break;
17029 case 59:
17030 BVCopyOpt_FixEncode(buf,*fasttest::BVCopyOpt_Castdown(header),soh);
17031 break;
17032 case 42:
17033 BVDflt_FixEncode(buf,*fasttest::BVDflt_Castdown(header),soh);
17034 break;
17035 case 44:
17036 BVDfltNull_FixEncode(buf,*fasttest::BVDfltNull_Castdown(header),soh);
17037 break;
17038 case 43:
17039 BVDfltOpt_FixEncode(buf,*fasttest::BVDfltOpt_Castdown(header),soh);
17040 break;
17041 case 7:
17042 BVNone_FixEncode(buf,*fasttest::BVNone_Castdown(header),soh);
17043 break;
17044 case 8:
17045 BVNoneOpt_FixEncode(buf,*fasttest::BVNoneOpt_Castdown(header),soh);
17046 break;
17047 case 115:
17048 GroupSgmOpt_FixEncode(buf,*fasttest::GroupSgmOpt_Castdown(header),soh);
17049 break;
17050 case 113:
17051 GroupTrv_FixEncode(buf,*fasttest::GroupTrv_Castdown(header),soh);
17052 break;
17053 case 114:
17054 GroupTrvOpt_FixEncode(buf,*fasttest::GroupTrvOpt_Castdown(header),soh);
17055 break;
17056 case 17:
17057 I32Const_FixEncode(buf,*fasttest::I32Const_Castdown(header),soh);
17058 break;
17059 case 18:
17060 I32ConstOpt_FixEncode(buf,*fasttest::I32ConstOpt_Castdown(header),soh);
17061 break;
17062 case 49:
17063 I32Copy_FixEncode(buf,*fasttest::I32Copy_Castdown(header),soh);
17064 break;
17065 case 51:
17066 I32CopyNull_FixEncode(buf,*fasttest::I32CopyNull_Castdown(header),soh);
17067 break;
17068 case 50:
17069 I32CopyOpt_FixEncode(buf,*fasttest::I32CopyOpt_Castdown(header),soh);
17070 break;
17071 case 65:
17072 I32Delta_FixEncode(buf,*fasttest::I32Delta_Castdown(header),soh);
17073 break;
17074 case 66:
17075 I32DeltaImpl_FixEncode(buf,*fasttest::I32DeltaImpl_Castdown(header),soh);
17076 break;
17077 case 68:
17078 I32DeltaNull_FixEncode(buf,*fasttest::I32DeltaNull_Castdown(header),soh);
17079 break;
17080 case 67:
17081 I32DeltaOpt_FixEncode(buf,*fasttest::I32DeltaOpt_Castdown(header),soh);
17082 break;
17083 case 33:
17084 I32Dflt_FixEncode(buf,*fasttest::I32Dflt_Castdown(header),soh);
17085 break;
17086 case 35:
17087 I32DfltNull_FixEncode(buf,*fasttest::I32DfltNull_Castdown(header),soh);
17088 break;
17089 case 34:
17090 I32DfltOpt_FixEncode(buf,*fasttest::I32DfltOpt_Castdown(header),soh);
17091 break;
17092 case 97:
17093 I32Incr_FixEncode(buf,*fasttest::I32Incr_Castdown(header),soh);
17094 break;
17095 case 98:
17096 I32IncrNV_FixEncode(buf,*fasttest::I32IncrNV_Castdown(header),soh);
17097 break;
17098 case 100:
17099 I32IncrNull_FixEncode(buf,*fasttest::I32IncrNull_Castdown(header),soh);
17100 break;
17101 case 99:
17102 I32IncrOpt_FixEncode(buf,*fasttest::I32IncrOpt_Castdown(header),soh);
17103 break;
17104 case 1:
17105 I32None_FixEncode(buf,*fasttest::I32None_Castdown(header),soh);
17106 break;
17107 case 2:
17108 I32NoneOpt_FixEncode(buf,*fasttest::I32NoneOpt_Castdown(header),soh);
17109 break;
17110 case 151:
17111 MsgPmap_FixEncode(buf,*fasttest::MsgPmap_Castdown(header),soh);
17112 break;
17113 case 120:
17114 Reset_FixEncode(buf,*fasttest::Reset_Castdown(header),soh);
17115 break;
17116 case 145:
17117 SampleEnumConst_FixEncode(buf,*fasttest::SampleEnumConst_Castdown(header),soh);
17118 break;
17119 case 147:
17120 SampleEnumCopy_FixEncode(buf,*fasttest::SampleEnumCopy_Castdown(header),soh);
17121 break;
17122 case 146:
17123 SampleEnumDefault_FixEncode(buf,*fasttest::SampleEnumDefault_Castdown(header),soh);
17124 break;
17125 case 148:
17126 SampleSetConst_FixEncode(buf,*fasttest::SampleSetConst_Castdown(header),soh);
17127 break;
17128 case 150:
17129 SampleSetCopy_FixEncode(buf,*fasttest::SampleSetCopy_Castdown(header),soh);
17130 break;
17131 case 149:
17132 SampleSetDefault_FixEncode(buf,*fasttest::SampleSetDefault_Castdown(header),soh);
17133 break;
17134 case 25:
17135 SclConst_FixEncode(buf,*fasttest::SclConst_Castdown(header),soh);
17136 break;
17137 case 26:
17138 SclConstOpt_FixEncode(buf,*fasttest::SclConstOpt_Castdown(header),soh);
17139 break;
17140 case 61:
17141 SclCopy_FixEncode(buf,*fasttest::SclCopy_Castdown(header),soh);
17142 break;
17143 case 63:
17144 SclCopyNull_FixEncode(buf,*fasttest::SclCopyNull_Castdown(header),soh);
17145 break;
17146 case 62:
17147 SclCopyOpt_FixEncode(buf,*fasttest::SclCopyOpt_Castdown(header),soh);
17148 break;
17149 case 81:
17150 SclDelta_FixEncode(buf,*fasttest::SclDelta_Castdown(header),soh);
17151 break;
17152 case 82:
17153 SclDeltaImpl_FixEncode(buf,*fasttest::SclDeltaImpl_Castdown(header),soh);
17154 break;
17155 case 84:
17156 SclDeltaNull_FixEncode(buf,*fasttest::SclDeltaNull_Castdown(header),soh);
17157 break;
17158 case 83:
17159 SclDeltaOpt_FixEncode(buf,*fasttest::SclDeltaOpt_Castdown(header),soh);
17160 break;
17161 case 45:
17162 SclDflt_FixEncode(buf,*fasttest::SclDflt_Castdown(header),soh);
17163 break;
17164 case 47:
17165 SclDfltNull_FixEncode(buf,*fasttest::SclDfltNull_Castdown(header),soh);
17166 break;
17167 case 46:
17168 SclDfltOpt_FixEncode(buf,*fasttest::SclDfltOpt_Castdown(header),soh);
17169 break;
17170 case 9:
17171 SclNone_FixEncode(buf,*fasttest::SclNone_Castdown(header),soh);
17172 break;
17173 case 10:
17174 SclNoneOpt_FixEncode(buf,*fasttest::SclNoneOpt_Castdown(header),soh);
17175 break;
17176 case 135:
17177 SeqOrder_FixEncode(buf,*fasttest::SeqOrder_Castdown(header),soh);
17178 break;
17179 case 118:
17180 SeqSgmOpt_FixEncode(buf,*fasttest::SeqSgmOpt_Castdown(header),soh);
17181 break;
17182 case 116:
17183 SeqTrv_FixEncode(buf,*fasttest::SeqTrv_Castdown(header),soh);
17184 break;
17185 case 131:
17186 SeqTrvLenConst_FixEncode(buf,*fasttest::SeqTrvLenConst_Castdown(header),soh);
17187 break;
17188 case 132:
17189 SeqTrvLenConstOpt_FixEncode(buf,*fasttest::SeqTrvLenConstOpt_Castdown(header),soh);
17190 break;
17191 case 133:
17192 SeqTrvLenDflt_FixEncode(buf,*fasttest::SeqTrvLenDflt_Castdown(header),soh);
17193 break;
17194 case 134:
17195 SeqTrvLenDfltOpt_FixEncode(buf,*fasttest::SeqTrvLenDfltOpt_Castdown(header),soh);
17196 break;
17197 case 129:
17198 SeqTrvLenNone_FixEncode(buf,*fasttest::SeqTrvLenNone_Castdown(header),soh);
17199 break;
17200 case 130:
17201 SeqTrvLenNoneOpt_FixEncode(buf,*fasttest::SeqTrvLenNoneOpt_Castdown(header),soh);
17202 break;
17203 case 117:
17204 SeqTrvOpt_FixEncode(buf,*fasttest::SeqTrvOpt_Castdown(header),soh);
17205 break;
17206 case 21:
17207 StrConst_FixEncode(buf,*fasttest::StrConst_Castdown(header),soh);
17208 break;
17209 case 22:
17210 StrConstOpt_FixEncode(buf,*fasttest::StrConstOpt_Castdown(header),soh);
17211 break;
17212 case 55:
17213 StrCopy_FixEncode(buf,*fasttest::StrCopy_Castdown(header),soh);
17214 break;
17215 case 57:
17216 StrCopyNull_FixEncode(buf,*fasttest::StrCopyNull_Castdown(header),soh);
17217 break;
17218 case 56:
17219 StrCopyOpt_FixEncode(buf,*fasttest::StrCopyOpt_Castdown(header),soh);
17220 break;
17221 case 39:
17222 StrDflt_FixEncode(buf,*fasttest::StrDflt_Castdown(header),soh);
17223 break;
17224 case 41:
17225 StrDfltNull_FixEncode(buf,*fasttest::StrDfltNull_Castdown(header),soh);
17226 break;
17227 case 40:
17228 StrDfltOpt_FixEncode(buf,*fasttest::StrDfltOpt_Castdown(header),soh);
17229 break;
17230 case 5:
17231 StrNone_FixEncode(buf,*fasttest::StrNone_Castdown(header),soh);
17232 break;
17233 case 6:
17234 StrNoneOpt_FixEncode(buf,*fasttest::StrNoneOpt_Castdown(header),soh);
17235 break;
17236 case 19:
17237 U32Const_FixEncode(buf,*fasttest::U32Const_Castdown(header),soh);
17238 break;
17239 case 20:
17240 U32ConstOpt_FixEncode(buf,*fasttest::U32ConstOpt_Castdown(header),soh);
17241 break;
17242 case 52:
17243 U32Copy_FixEncode(buf,*fasttest::U32Copy_Castdown(header),soh);
17244 break;
17245 case 54:
17246 U32CopyNull_FixEncode(buf,*fasttest::U32CopyNull_Castdown(header),soh);
17247 break;
17248 case 53:
17249 U32CopyOpt_FixEncode(buf,*fasttest::U32CopyOpt_Castdown(header),soh);
17250 break;
17251 case 69:
17252 U32Delta_FixEncode(buf,*fasttest::U32Delta_Castdown(header),soh);
17253 break;
17254 case 70:
17255 U32DeltaImpl_FixEncode(buf,*fasttest::U32DeltaImpl_Castdown(header),soh);
17256 break;
17257 case 72:
17258 U32DeltaNull_FixEncode(buf,*fasttest::U32DeltaNull_Castdown(header),soh);
17259 break;
17260 case 71:
17261 U32DeltaOpt_FixEncode(buf,*fasttest::U32DeltaOpt_Castdown(header),soh);
17262 break;
17263 case 36:
17264 U32Dflt_FixEncode(buf,*fasttest::U32Dflt_Castdown(header),soh);
17265 break;
17266 case 38:
17267 U32DfltNull_FixEncode(buf,*fasttest::U32DfltNull_Castdown(header),soh);
17268 break;
17269 case 37:
17270 U32DfltOpt_FixEncode(buf,*fasttest::U32DfltOpt_Castdown(header),soh);
17271 break;
17272 case 101:
17273 U32Incr_FixEncode(buf,*fasttest::U32Incr_Castdown(header),soh);
17274 break;
17275 case 102:
17276 U32IncrNV_FixEncode(buf,*fasttest::U32IncrNV_Castdown(header),soh);
17277 break;
17278 case 104:
17279 U32IncrNull_FixEncode(buf,*fasttest::U32IncrNull_Castdown(header),soh);
17280 break;
17281 case 103:
17282 U32IncrOpt_FixEncode(buf,*fasttest::U32IncrOpt_Castdown(header),soh);
17283 break;
17284 case 3:
17285 U32None_FixEncode(buf,*fasttest::U32None_Castdown(header),soh);
17286 break;
17287 case 4:
17288 U32NoneOpt_FixEncode(buf,*fasttest::U32NoneOpt_Castdown(header),soh);
17289 break;
17290 }
17291}
17292
17293// --- fasttest.TemplateHeaderMsgs..Print
17294// Print message to STR. If message is too short for MSG_LEN, print nothing.
17295// MSG.LENGTH must have already been validated against msg_len.
17296// This function will additionally validate that sizeof(Msg) <= msg_len
17297bool fasttest::TemplateHeaderMsgs_Print(algo::cstring &str, fasttest::TemplateHeader &msg, u32 msg_len) {
17298 switch(msg.id) {
17299 case 23: {
17300 if (sizeof(fasttest::BVConst) > msg_len) { return false; }
17301 BVConst_Print((fasttest::BVConst&)(msg), str);
17302 return true;
17303 }
17304 case 24: {
17305 if (sizeof(fasttest::BVConstOpt) > msg_len) { return false; }
17306 BVConstOpt_Print((fasttest::BVConstOpt&)(msg), str);
17307 return true;
17308 }
17309 case 58: {
17310 if (sizeof(fasttest::BVCopy) > msg_len) { return false; }
17311 BVCopy_Print((fasttest::BVCopy&)(msg), str);
17312 return true;
17313 }
17314 case 60: {
17315 if (sizeof(fasttest::BVCopyNull) > msg_len) { return false; }
17316 BVCopyNull_Print((fasttest::BVCopyNull&)(msg), str);
17317 return true;
17318 }
17319 case 59: {
17320 if (sizeof(fasttest::BVCopyOpt) > msg_len) { return false; }
17321 BVCopyOpt_Print((fasttest::BVCopyOpt&)(msg), str);
17322 return true;
17323 }
17324 case 42: {
17325 if (sizeof(fasttest::BVDflt) > msg_len) { return false; }
17326 BVDflt_Print((fasttest::BVDflt&)(msg), str);
17327 return true;
17328 }
17329 case 44: {
17330 if (sizeof(fasttest::BVDfltNull) > msg_len) { return false; }
17331 BVDfltNull_Print((fasttest::BVDfltNull&)(msg), str);
17332 return true;
17333 }
17334 case 43: {
17335 if (sizeof(fasttest::BVDfltOpt) > msg_len) { return false; }
17336 BVDfltOpt_Print((fasttest::BVDfltOpt&)(msg), str);
17337 return true;
17338 }
17339 case 7: {
17340 if (sizeof(fasttest::BVNone) > msg_len) { return false; }
17341 BVNone_Print((fasttest::BVNone&)(msg), str);
17342 return true;
17343 }
17344 case 8: {
17345 if (sizeof(fasttest::BVNoneOpt) > msg_len) { return false; }
17346 BVNoneOpt_Print((fasttest::BVNoneOpt&)(msg), str);
17347 return true;
17348 }
17349 case 115: {
17350 if (sizeof(fasttest::GroupSgmOpt) > msg_len) { return false; }
17351 GroupSgmOpt_Print((fasttest::GroupSgmOpt&)(msg), str);
17352 return true;
17353 }
17354 case 113: {
17355 if (sizeof(fasttest::GroupTrv) > msg_len) { return false; }
17356 GroupTrv_Print((fasttest::GroupTrv&)(msg), str);
17357 return true;
17358 }
17359 case 114: {
17360 if (sizeof(fasttest::GroupTrvOpt) > msg_len) { return false; }
17361 GroupTrvOpt_Print((fasttest::GroupTrvOpt&)(msg), str);
17362 return true;
17363 }
17364 case 17: {
17365 if (sizeof(fasttest::I32Const) > msg_len) { return false; }
17366 I32Const_Print((fasttest::I32Const&)(msg), str);
17367 return true;
17368 }
17369 case 18: {
17370 if (sizeof(fasttest::I32ConstOpt) > msg_len) { return false; }
17371 I32ConstOpt_Print((fasttest::I32ConstOpt&)(msg), str);
17372 return true;
17373 }
17374 case 49: {
17375 if (sizeof(fasttest::I32Copy) > msg_len) { return false; }
17376 I32Copy_Print((fasttest::I32Copy&)(msg), str);
17377 return true;
17378 }
17379 case 51: {
17380 if (sizeof(fasttest::I32CopyNull) > msg_len) { return false; }
17381 I32CopyNull_Print((fasttest::I32CopyNull&)(msg), str);
17382 return true;
17383 }
17384 case 50: {
17385 if (sizeof(fasttest::I32CopyOpt) > msg_len) { return false; }
17386 I32CopyOpt_Print((fasttest::I32CopyOpt&)(msg), str);
17387 return true;
17388 }
17389 case 65: {
17390 if (sizeof(fasttest::I32Delta) > msg_len) { return false; }
17391 I32Delta_Print((fasttest::I32Delta&)(msg), str);
17392 return true;
17393 }
17394 case 66: {
17395 if (sizeof(fasttest::I32DeltaImpl) > msg_len) { return false; }
17396 I32DeltaImpl_Print((fasttest::I32DeltaImpl&)(msg), str);
17397 return true;
17398 }
17399 case 68: {
17400 if (sizeof(fasttest::I32DeltaNull) > msg_len) { return false; }
17401 I32DeltaNull_Print((fasttest::I32DeltaNull&)(msg), str);
17402 return true;
17403 }
17404 case 67: {
17405 if (sizeof(fasttest::I32DeltaOpt) > msg_len) { return false; }
17406 I32DeltaOpt_Print((fasttest::I32DeltaOpt&)(msg), str);
17407 return true;
17408 }
17409 case 33: {
17410 if (sizeof(fasttest::I32Dflt) > msg_len) { return false; }
17411 I32Dflt_Print((fasttest::I32Dflt&)(msg), str);
17412 return true;
17413 }
17414 case 35: {
17415 if (sizeof(fasttest::I32DfltNull) > msg_len) { return false; }
17416 I32DfltNull_Print((fasttest::I32DfltNull&)(msg), str);
17417 return true;
17418 }
17419 case 34: {
17420 if (sizeof(fasttest::I32DfltOpt) > msg_len) { return false; }
17421 I32DfltOpt_Print((fasttest::I32DfltOpt&)(msg), str);
17422 return true;
17423 }
17424 case 97: {
17425 if (sizeof(fasttest::I32Incr) > msg_len) { return false; }
17426 I32Incr_Print((fasttest::I32Incr&)(msg), str);
17427 return true;
17428 }
17429 case 98: {
17430 if (sizeof(fasttest::I32IncrNV) > msg_len) { return false; }
17431 I32IncrNV_Print((fasttest::I32IncrNV&)(msg), str);
17432 return true;
17433 }
17434 case 100: {
17435 if (sizeof(fasttest::I32IncrNull) > msg_len) { return false; }
17436 I32IncrNull_Print((fasttest::I32IncrNull&)(msg), str);
17437 return true;
17438 }
17439 case 99: {
17440 if (sizeof(fasttest::I32IncrOpt) > msg_len) { return false; }
17441 I32IncrOpt_Print((fasttest::I32IncrOpt&)(msg), str);
17442 return true;
17443 }
17444 case 1: {
17445 if (sizeof(fasttest::I32None) > msg_len) { return false; }
17446 I32None_Print((fasttest::I32None&)(msg), str);
17447 return true;
17448 }
17449 case 2: {
17450 if (sizeof(fasttest::I32NoneOpt) > msg_len) { return false; }
17451 I32NoneOpt_Print((fasttest::I32NoneOpt&)(msg), str);
17452 return true;
17453 }
17454 case 151: {
17455 if (sizeof(fasttest::MsgPmap) > msg_len) { return false; }
17456 MsgPmap_Print((fasttest::MsgPmap&)(msg), str);
17457 return true;
17458 }
17459 case 120: {
17460 if (sizeof(fasttest::Reset) > msg_len) { return false; }
17461 Reset_Print((fasttest::Reset&)(msg), str);
17462 return true;
17463 }
17464 case 145: {
17465 if (sizeof(fasttest::SampleEnumConst) > msg_len) { return false; }
17466 SampleEnumConst_Print((fasttest::SampleEnumConst&)(msg), str);
17467 return true;
17468 }
17469 case 147: {
17470 if (sizeof(fasttest::SampleEnumCopy) > msg_len) { return false; }
17471 SampleEnumCopy_Print((fasttest::SampleEnumCopy&)(msg), str);
17472 return true;
17473 }
17474 case 146: {
17475 if (sizeof(fasttest::SampleEnumDefault) > msg_len) { return false; }
17476 SampleEnumDefault_Print((fasttest::SampleEnumDefault&)(msg), str);
17477 return true;
17478 }
17479 case 148: {
17480 if (sizeof(fasttest::SampleSetConst) > msg_len) { return false; }
17481 SampleSetConst_Print((fasttest::SampleSetConst&)(msg), str);
17482 return true;
17483 }
17484 case 150: {
17485 if (sizeof(fasttest::SampleSetCopy) > msg_len) { return false; }
17486 SampleSetCopy_Print((fasttest::SampleSetCopy&)(msg), str);
17487 return true;
17488 }
17489 case 149: {
17490 if (sizeof(fasttest::SampleSetDefault) > msg_len) { return false; }
17491 SampleSetDefault_Print((fasttest::SampleSetDefault&)(msg), str);
17492 return true;
17493 }
17494 case 25: {
17495 if (sizeof(fasttest::SclConst) > msg_len) { return false; }
17496 SclConst_Print((fasttest::SclConst&)(msg), str);
17497 return true;
17498 }
17499 case 26: {
17500 if (sizeof(fasttest::SclConstOpt) > msg_len) { return false; }
17501 SclConstOpt_Print((fasttest::SclConstOpt&)(msg), str);
17502 return true;
17503 }
17504 case 61: {
17505 if (sizeof(fasttest::SclCopy) > msg_len) { return false; }
17506 SclCopy_Print((fasttest::SclCopy&)(msg), str);
17507 return true;
17508 }
17509 case 63: {
17510 if (sizeof(fasttest::SclCopyNull) > msg_len) { return false; }
17511 SclCopyNull_Print((fasttest::SclCopyNull&)(msg), str);
17512 return true;
17513 }
17514 case 62: {
17515 if (sizeof(fasttest::SclCopyOpt) > msg_len) { return false; }
17516 SclCopyOpt_Print((fasttest::SclCopyOpt&)(msg), str);
17517 return true;
17518 }
17519 case 81: {
17520 if (sizeof(fasttest::SclDelta) > msg_len) { return false; }
17521 SclDelta_Print((fasttest::SclDelta&)(msg), str);
17522 return true;
17523 }
17524 case 82: {
17525 if (sizeof(fasttest::SclDeltaImpl) > msg_len) { return false; }
17526 SclDeltaImpl_Print((fasttest::SclDeltaImpl&)(msg), str);
17527 return true;
17528 }
17529 case 84: {
17530 if (sizeof(fasttest::SclDeltaNull) > msg_len) { return false; }
17531 SclDeltaNull_Print((fasttest::SclDeltaNull&)(msg), str);
17532 return true;
17533 }
17534 case 83: {
17535 if (sizeof(fasttest::SclDeltaOpt) > msg_len) { return false; }
17536 SclDeltaOpt_Print((fasttest::SclDeltaOpt&)(msg), str);
17537 return true;
17538 }
17539 case 45: {
17540 if (sizeof(fasttest::SclDflt) > msg_len) { return false; }
17541 SclDflt_Print((fasttest::SclDflt&)(msg), str);
17542 return true;
17543 }
17544 case 47: {
17545 if (sizeof(fasttest::SclDfltNull) > msg_len) { return false; }
17546 SclDfltNull_Print((fasttest::SclDfltNull&)(msg), str);
17547 return true;
17548 }
17549 case 46: {
17550 if (sizeof(fasttest::SclDfltOpt) > msg_len) { return false; }
17551 SclDfltOpt_Print((fasttest::SclDfltOpt&)(msg), str);
17552 return true;
17553 }
17554 case 9: {
17555 if (sizeof(fasttest::SclNone) > msg_len) { return false; }
17556 SclNone_Print((fasttest::SclNone&)(msg), str);
17557 return true;
17558 }
17559 case 10: {
17560 if (sizeof(fasttest::SclNoneOpt) > msg_len) { return false; }
17561 SclNoneOpt_Print((fasttest::SclNoneOpt&)(msg), str);
17562 return true;
17563 }
17564 case 135: {
17565 if (sizeof(fasttest::SeqOrder) > msg_len) { return false; }
17566 SeqOrder_Print((fasttest::SeqOrder&)(msg), str);
17567 return true;
17568 }
17569 case 118: {
17570 if (sizeof(fasttest::SeqSgmOpt) > msg_len) { return false; }
17571 SeqSgmOpt_Print((fasttest::SeqSgmOpt&)(msg), str);
17572 return true;
17573 }
17574 case 116: {
17575 if (sizeof(fasttest::SeqTrv) > msg_len) { return false; }
17576 SeqTrv_Print((fasttest::SeqTrv&)(msg), str);
17577 return true;
17578 }
17579 case 131: {
17580 if (sizeof(fasttest::SeqTrvLenConst) > msg_len) { return false; }
17581 SeqTrvLenConst_Print((fasttest::SeqTrvLenConst&)(msg), str);
17582 return true;
17583 }
17584 case 132: {
17585 if (sizeof(fasttest::SeqTrvLenConstOpt) > msg_len) { return false; }
17586 SeqTrvLenConstOpt_Print((fasttest::SeqTrvLenConstOpt&)(msg), str);
17587 return true;
17588 }
17589 case 133: {
17590 if (sizeof(fasttest::SeqTrvLenDflt) > msg_len) { return false; }
17591 SeqTrvLenDflt_Print((fasttest::SeqTrvLenDflt&)(msg), str);
17592 return true;
17593 }
17594 case 134: {
17595 if (sizeof(fasttest::SeqTrvLenDfltOpt) > msg_len) { return false; }
17596 SeqTrvLenDfltOpt_Print((fasttest::SeqTrvLenDfltOpt&)(msg), str);
17597 return true;
17598 }
17599 case 129: {
17600 if (sizeof(fasttest::SeqTrvLenNone) > msg_len) { return false; }
17601 SeqTrvLenNone_Print((fasttest::SeqTrvLenNone&)(msg), str);
17602 return true;
17603 }
17604 case 130: {
17605 if (sizeof(fasttest::SeqTrvLenNoneOpt) > msg_len) { return false; }
17606 SeqTrvLenNoneOpt_Print((fasttest::SeqTrvLenNoneOpt&)(msg), str);
17607 return true;
17608 }
17609 case 117: {
17610 if (sizeof(fasttest::SeqTrvOpt) > msg_len) { return false; }
17611 SeqTrvOpt_Print((fasttest::SeqTrvOpt&)(msg), str);
17612 return true;
17613 }
17614 case 21: {
17615 if (sizeof(fasttest::StrConst) > msg_len) { return false; }
17616 StrConst_Print((fasttest::StrConst&)(msg), str);
17617 return true;
17618 }
17619 case 22: {
17620 if (sizeof(fasttest::StrConstOpt) > msg_len) { return false; }
17621 StrConstOpt_Print((fasttest::StrConstOpt&)(msg), str);
17622 return true;
17623 }
17624 case 55: {
17625 if (sizeof(fasttest::StrCopy) > msg_len) { return false; }
17626 StrCopy_Print((fasttest::StrCopy&)(msg), str);
17627 return true;
17628 }
17629 case 57: {
17630 if (sizeof(fasttest::StrCopyNull) > msg_len) { return false; }
17631 StrCopyNull_Print((fasttest::StrCopyNull&)(msg), str);
17632 return true;
17633 }
17634 case 56: {
17635 if (sizeof(fasttest::StrCopyOpt) > msg_len) { return false; }
17636 StrCopyOpt_Print((fasttest::StrCopyOpt&)(msg), str);
17637 return true;
17638 }
17639 case 39: {
17640 if (sizeof(fasttest::StrDflt) > msg_len) { return false; }
17641 StrDflt_Print((fasttest::StrDflt&)(msg), str);
17642 return true;
17643 }
17644 case 41: {
17645 if (sizeof(fasttest::StrDfltNull) > msg_len) { return false; }
17646 StrDfltNull_Print((fasttest::StrDfltNull&)(msg), str);
17647 return true;
17648 }
17649 case 40: {
17650 if (sizeof(fasttest::StrDfltOpt) > msg_len) { return false; }
17651 StrDfltOpt_Print((fasttest::StrDfltOpt&)(msg), str);
17652 return true;
17653 }
17654 case 5: {
17655 if (sizeof(fasttest::StrNone) > msg_len) { return false; }
17656 StrNone_Print((fasttest::StrNone&)(msg), str);
17657 return true;
17658 }
17659 case 6: {
17660 if (sizeof(fasttest::StrNoneOpt) > msg_len) { return false; }
17661 StrNoneOpt_Print((fasttest::StrNoneOpt&)(msg), str);
17662 return true;
17663 }
17664 case 19: {
17665 if (sizeof(fasttest::U32Const) > msg_len) { return false; }
17666 U32Const_Print((fasttest::U32Const&)(msg), str);
17667 return true;
17668 }
17669 case 20: {
17670 if (sizeof(fasttest::U32ConstOpt) > msg_len) { return false; }
17671 U32ConstOpt_Print((fasttest::U32ConstOpt&)(msg), str);
17672 return true;
17673 }
17674 case 52: {
17675 if (sizeof(fasttest::U32Copy) > msg_len) { return false; }
17676 U32Copy_Print((fasttest::U32Copy&)(msg), str);
17677 return true;
17678 }
17679 case 54: {
17680 if (sizeof(fasttest::U32CopyNull) > msg_len) { return false; }
17681 U32CopyNull_Print((fasttest::U32CopyNull&)(msg), str);
17682 return true;
17683 }
17684 case 53: {
17685 if (sizeof(fasttest::U32CopyOpt) > msg_len) { return false; }
17686 U32CopyOpt_Print((fasttest::U32CopyOpt&)(msg), str);
17687 return true;
17688 }
17689 case 69: {
17690 if (sizeof(fasttest::U32Delta) > msg_len) { return false; }
17691 U32Delta_Print((fasttest::U32Delta&)(msg), str);
17692 return true;
17693 }
17694 case 70: {
17695 if (sizeof(fasttest::U32DeltaImpl) > msg_len) { return false; }
17696 U32DeltaImpl_Print((fasttest::U32DeltaImpl&)(msg), str);
17697 return true;
17698 }
17699 case 72: {
17700 if (sizeof(fasttest::U32DeltaNull) > msg_len) { return false; }
17701 U32DeltaNull_Print((fasttest::U32DeltaNull&)(msg), str);
17702 return true;
17703 }
17704 case 71: {
17705 if (sizeof(fasttest::U32DeltaOpt) > msg_len) { return false; }
17706 U32DeltaOpt_Print((fasttest::U32DeltaOpt&)(msg), str);
17707 return true;
17708 }
17709 case 36: {
17710 if (sizeof(fasttest::U32Dflt) > msg_len) { return false; }
17711 U32Dflt_Print((fasttest::U32Dflt&)(msg), str);
17712 return true;
17713 }
17714 case 38: {
17715 if (sizeof(fasttest::U32DfltNull) > msg_len) { return false; }
17716 U32DfltNull_Print((fasttest::U32DfltNull&)(msg), str);
17717 return true;
17718 }
17719 case 37: {
17720 if (sizeof(fasttest::U32DfltOpt) > msg_len) { return false; }
17721 U32DfltOpt_Print((fasttest::U32DfltOpt&)(msg), str);
17722 return true;
17723 }
17724 case 101: {
17725 if (sizeof(fasttest::U32Incr) > msg_len) { return false; }
17726 U32Incr_Print((fasttest::U32Incr&)(msg), str);
17727 return true;
17728 }
17729 case 102: {
17730 if (sizeof(fasttest::U32IncrNV) > msg_len) { return false; }
17731 U32IncrNV_Print((fasttest::U32IncrNV&)(msg), str);
17732 return true;
17733 }
17734 case 104: {
17735 if (sizeof(fasttest::U32IncrNull) > msg_len) { return false; }
17736 U32IncrNull_Print((fasttest::U32IncrNull&)(msg), str);
17737 return true;
17738 }
17739 case 103: {
17740 if (sizeof(fasttest::U32IncrOpt) > msg_len) { return false; }
17741 U32IncrOpt_Print((fasttest::U32IncrOpt&)(msg), str);
17742 return true;
17743 }
17744 case 3: {
17745 if (sizeof(fasttest::U32None) > msg_len) { return false; }
17746 U32None_Print((fasttest::U32None&)(msg), str);
17747 return true;
17748 }
17749 case 4: {
17750 if (sizeof(fasttest::U32NoneOpt) > msg_len) { return false; }
17751 U32NoneOpt_Print((fasttest::U32NoneOpt&)(msg), str);
17752 return true;
17753 }
17754 default:
17755
17756 return false;
17757 }
17758}
17759
17760// --- fasttest.TemplateHeaderMsgs..ReadStrptr
17761// Parse ascii representation of message into binary, appending new data to BUF.
17762fasttest::TemplateHeaderMsgsCase fasttest::TemplateHeaderMsgs_ReadStrptr(algo::strptr str, algo::ByteAry &buf) {
17763 bool ok = false;
17764 tempstr msgtype_str;
17765 algo::StringIter iter(str);
17766 cstring_ReadCmdarg(msgtype_str, iter, false); // read first word
17767 fasttest::TemplateHeaderMsgsCase msgtype;
17768 value_SetStrptrMaybe(msgtype, msgtype_str); // map string -> enum
17769 switch (value_GetEnum(msgtype)) { // what message is it?
17770 case fasttest_TemplateHeaderMsgsCase_fasttest_BVConst: {
17771 int len = sizeof(fasttest::BVConst);
17772 fasttest::BVConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVConst; // default values
17773 ok = BVConst_ReadStrptrMaybe(*ctype, str); // now read attributes
17774 } break; // fasttest::BVConst case
17775
17776 case fasttest_TemplateHeaderMsgsCase_fasttest_BVConstOpt: {
17777 int len = sizeof(fasttest::BVConstOpt);
17778 fasttest::BVConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVConstOpt; // default values
17779 ok = BVConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17780 } break; // fasttest::BVConstOpt case
17781
17782 case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopy: {
17783 int len = sizeof(fasttest::BVCopy);
17784 fasttest::BVCopy *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVCopy; // default values
17785 ok = BVCopy_ReadStrptrMaybe(*ctype, str); // now read attributes
17786 } break; // fasttest::BVCopy case
17787
17788 case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyNull: {
17789 int len = sizeof(fasttest::BVCopyNull);
17790 fasttest::BVCopyNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVCopyNull; // default values
17791 ok = BVCopyNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17792 } break; // fasttest::BVCopyNull case
17793
17794 case fasttest_TemplateHeaderMsgsCase_fasttest_BVCopyOpt: {
17795 int len = sizeof(fasttest::BVCopyOpt);
17796 fasttest::BVCopyOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVCopyOpt; // default values
17797 ok = BVCopyOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17798 } break; // fasttest::BVCopyOpt case
17799
17800 case fasttest_TemplateHeaderMsgsCase_fasttest_BVDflt: {
17801 int len = sizeof(fasttest::BVDflt);
17802 fasttest::BVDflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVDflt; // default values
17803 ok = BVDflt_ReadStrptrMaybe(*ctype, str); // now read attributes
17804 } break; // fasttest::BVDflt case
17805
17806 case fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltNull: {
17807 int len = sizeof(fasttest::BVDfltNull);
17808 fasttest::BVDfltNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVDfltNull; // default values
17809 ok = BVDfltNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17810 } break; // fasttest::BVDfltNull case
17811
17812 case fasttest_TemplateHeaderMsgsCase_fasttest_BVDfltOpt: {
17813 int len = sizeof(fasttest::BVDfltOpt);
17814 fasttest::BVDfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVDfltOpt; // default values
17815 ok = BVDfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17816 } break; // fasttest::BVDfltOpt case
17817
17818 case fasttest_TemplateHeaderMsgsCase_fasttest_BVNone: {
17819 int len = sizeof(fasttest::BVNone);
17820 fasttest::BVNone *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVNone; // default values
17821 ok = BVNone_ReadStrptrMaybe(*ctype, str); // now read attributes
17822 } break; // fasttest::BVNone case
17823
17824 case fasttest_TemplateHeaderMsgsCase_fasttest_BVNoneOpt: {
17825 int len = sizeof(fasttest::BVNoneOpt);
17826 fasttest::BVNoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::BVNoneOpt; // default values
17827 ok = BVNoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17828 } break; // fasttest::BVNoneOpt case
17829
17830 case fasttest_TemplateHeaderMsgsCase_fasttest_GroupSgmOpt: {
17831 int len = sizeof(fasttest::GroupSgmOpt);
17832 fasttest::GroupSgmOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::GroupSgmOpt; // default values
17833 ok = GroupSgmOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17834 } break; // fasttest::GroupSgmOpt case
17835
17836 case fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrv: {
17837 int len = sizeof(fasttest::GroupTrv);
17838 fasttest::GroupTrv *ctype = new(ary_AllocN(buf, len).elems) fasttest::GroupTrv; // default values
17839 ok = GroupTrv_ReadStrptrMaybe(*ctype, str); // now read attributes
17840 } break; // fasttest::GroupTrv case
17841
17842 case fasttest_TemplateHeaderMsgsCase_fasttest_GroupTrvOpt: {
17843 int len = sizeof(fasttest::GroupTrvOpt);
17844 fasttest::GroupTrvOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::GroupTrvOpt; // default values
17845 ok = GroupTrvOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17846 } break; // fasttest::GroupTrvOpt case
17847
17848 case fasttest_TemplateHeaderMsgsCase_fasttest_I32Const: {
17849 int len = sizeof(fasttest::I32Const);
17850 fasttest::I32Const *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32Const; // default values
17851 ok = I32Const_ReadStrptrMaybe(*ctype, str); // now read attributes
17852 } break; // fasttest::I32Const case
17853
17854 case fasttest_TemplateHeaderMsgsCase_fasttest_I32ConstOpt: {
17855 int len = sizeof(fasttest::I32ConstOpt);
17856 fasttest::I32ConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32ConstOpt; // default values
17857 ok = I32ConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17858 } break; // fasttest::I32ConstOpt case
17859
17860 case fasttest_TemplateHeaderMsgsCase_fasttest_I32Copy: {
17861 int len = sizeof(fasttest::I32Copy);
17862 fasttest::I32Copy *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32Copy; // default values
17863 ok = I32Copy_ReadStrptrMaybe(*ctype, str); // now read attributes
17864 } break; // fasttest::I32Copy case
17865
17866 case fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyNull: {
17867 int len = sizeof(fasttest::I32CopyNull);
17868 fasttest::I32CopyNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32CopyNull; // default values
17869 ok = I32CopyNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17870 } break; // fasttest::I32CopyNull case
17871
17872 case fasttest_TemplateHeaderMsgsCase_fasttest_I32CopyOpt: {
17873 int len = sizeof(fasttest::I32CopyOpt);
17874 fasttest::I32CopyOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32CopyOpt; // default values
17875 ok = I32CopyOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17876 } break; // fasttest::I32CopyOpt case
17877
17878 case fasttest_TemplateHeaderMsgsCase_fasttest_I32Delta: {
17879 int len = sizeof(fasttest::I32Delta);
17880 fasttest::I32Delta *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32Delta; // default values
17881 ok = I32Delta_ReadStrptrMaybe(*ctype, str); // now read attributes
17882 } break; // fasttest::I32Delta case
17883
17884 case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaImpl: {
17885 int len = sizeof(fasttest::I32DeltaImpl);
17886 fasttest::I32DeltaImpl *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32DeltaImpl; // default values
17887 ok = I32DeltaImpl_ReadStrptrMaybe(*ctype, str); // now read attributes
17888 } break; // fasttest::I32DeltaImpl case
17889
17890 case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaNull: {
17891 int len = sizeof(fasttest::I32DeltaNull);
17892 fasttest::I32DeltaNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32DeltaNull; // default values
17893 ok = I32DeltaNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17894 } break; // fasttest::I32DeltaNull case
17895
17896 case fasttest_TemplateHeaderMsgsCase_fasttest_I32DeltaOpt: {
17897 int len = sizeof(fasttest::I32DeltaOpt);
17898 fasttest::I32DeltaOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32DeltaOpt; // default values
17899 ok = I32DeltaOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17900 } break; // fasttest::I32DeltaOpt case
17901
17902 case fasttest_TemplateHeaderMsgsCase_fasttest_I32Dflt: {
17903 int len = sizeof(fasttest::I32Dflt);
17904 fasttest::I32Dflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32Dflt; // default values
17905 ok = I32Dflt_ReadStrptrMaybe(*ctype, str); // now read attributes
17906 } break; // fasttest::I32Dflt case
17907
17908 case fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltNull: {
17909 int len = sizeof(fasttest::I32DfltNull);
17910 fasttest::I32DfltNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32DfltNull; // default values
17911 ok = I32DfltNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17912 } break; // fasttest::I32DfltNull case
17913
17914 case fasttest_TemplateHeaderMsgsCase_fasttest_I32DfltOpt: {
17915 int len = sizeof(fasttest::I32DfltOpt);
17916 fasttest::I32DfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32DfltOpt; // default values
17917 ok = I32DfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17918 } break; // fasttest::I32DfltOpt case
17919
17920 case fasttest_TemplateHeaderMsgsCase_fasttest_I32Incr: {
17921 int len = sizeof(fasttest::I32Incr);
17922 fasttest::I32Incr *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32Incr; // default values
17923 ok = I32Incr_ReadStrptrMaybe(*ctype, str); // now read attributes
17924 } break; // fasttest::I32Incr case
17925
17926 case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNV: {
17927 int len = sizeof(fasttest::I32IncrNV);
17928 fasttest::I32IncrNV *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32IncrNV; // default values
17929 ok = I32IncrNV_ReadStrptrMaybe(*ctype, str); // now read attributes
17930 } break; // fasttest::I32IncrNV case
17931
17932 case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrNull: {
17933 int len = sizeof(fasttest::I32IncrNull);
17934 fasttest::I32IncrNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32IncrNull; // default values
17935 ok = I32IncrNull_ReadStrptrMaybe(*ctype, str); // now read attributes
17936 } break; // fasttest::I32IncrNull case
17937
17938 case fasttest_TemplateHeaderMsgsCase_fasttest_I32IncrOpt: {
17939 int len = sizeof(fasttest::I32IncrOpt);
17940 fasttest::I32IncrOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32IncrOpt; // default values
17941 ok = I32IncrOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17942 } break; // fasttest::I32IncrOpt case
17943
17944 case fasttest_TemplateHeaderMsgsCase_fasttest_I32None: {
17945 int len = sizeof(fasttest::I32None);
17946 fasttest::I32None *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32None; // default values
17947 ok = I32None_ReadStrptrMaybe(*ctype, str); // now read attributes
17948 } break; // fasttest::I32None case
17949
17950 case fasttest_TemplateHeaderMsgsCase_fasttest_I32NoneOpt: {
17951 int len = sizeof(fasttest::I32NoneOpt);
17952 fasttest::I32NoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::I32NoneOpt; // default values
17953 ok = I32NoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
17954 } break; // fasttest::I32NoneOpt case
17955
17956 case fasttest_TemplateHeaderMsgsCase_fasttest_MsgPmap: {
17957 int len = sizeof(fasttest::MsgPmap);
17958 fasttest::MsgPmap *ctype = new(ary_AllocN(buf, len).elems) fasttest::MsgPmap; // default values
17959 ok = MsgPmap_ReadStrptrMaybe(*ctype, str); // now read attributes
17960 } break; // fasttest::MsgPmap case
17961
17962 case fasttest_TemplateHeaderMsgsCase_fasttest_Reset: {
17963 int len = sizeof(fasttest::Reset);
17964 fasttest::Reset *ctype = new(ary_AllocN(buf, len).elems) fasttest::Reset; // default values
17965 ok = Reset_ReadStrptrMaybe(*ctype, str); // now read attributes
17966 } break; // fasttest::Reset case
17967
17968 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumConst: {
17969 int len = sizeof(fasttest::SampleEnumConst);
17970 fasttest::SampleEnumConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleEnumConst; // default values
17971 ok = SampleEnumConst_ReadStrptrMaybe(*ctype, str); // now read attributes
17972 } break; // fasttest::SampleEnumConst case
17973
17974 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumCopy: {
17975 int len = sizeof(fasttest::SampleEnumCopy);
17976 fasttest::SampleEnumCopy *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleEnumCopy; // default values
17977 ok = SampleEnumCopy_ReadStrptrMaybe(*ctype, str); // now read attributes
17978 } break; // fasttest::SampleEnumCopy case
17979
17980 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleEnumDefault: {
17981 int len = sizeof(fasttest::SampleEnumDefault);
17982 fasttest::SampleEnumDefault *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleEnumDefault; // default values
17983 ok = SampleEnumDefault_ReadStrptrMaybe(*ctype, str); // now read attributes
17984 } break; // fasttest::SampleEnumDefault case
17985
17986 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetConst: {
17987 int len = sizeof(fasttest::SampleSetConst);
17988 fasttest::SampleSetConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleSetConst; // default values
17989 ok = SampleSetConst_ReadStrptrMaybe(*ctype, str); // now read attributes
17990 } break; // fasttest::SampleSetConst case
17991
17992 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetCopy: {
17993 int len = sizeof(fasttest::SampleSetCopy);
17994 fasttest::SampleSetCopy *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleSetCopy; // default values
17995 ok = SampleSetCopy_ReadStrptrMaybe(*ctype, str); // now read attributes
17996 } break; // fasttest::SampleSetCopy case
17997
17998 case fasttest_TemplateHeaderMsgsCase_fasttest_SampleSetDefault: {
17999 int len = sizeof(fasttest::SampleSetDefault);
18000 fasttest::SampleSetDefault *ctype = new(ary_AllocN(buf, len).elems) fasttest::SampleSetDefault; // default values
18001 ok = SampleSetDefault_ReadStrptrMaybe(*ctype, str); // now read attributes
18002 } break; // fasttest::SampleSetDefault case
18003
18004 case fasttest_TemplateHeaderMsgsCase_fasttest_SclConst: {
18005 int len = sizeof(fasttest::SclConst);
18006 fasttest::SclConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclConst; // default values
18007 ok = SclConst_ReadStrptrMaybe(*ctype, str); // now read attributes
18008 } break; // fasttest::SclConst case
18009
18010 case fasttest_TemplateHeaderMsgsCase_fasttest_SclConstOpt: {
18011 int len = sizeof(fasttest::SclConstOpt);
18012 fasttest::SclConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclConstOpt; // default values
18013 ok = SclConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18014 } break; // fasttest::SclConstOpt case
18015
18016 case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopy: {
18017 int len = sizeof(fasttest::SclCopy);
18018 fasttest::SclCopy *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclCopy; // default values
18019 ok = SclCopy_ReadStrptrMaybe(*ctype, str); // now read attributes
18020 } break; // fasttest::SclCopy case
18021
18022 case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyNull: {
18023 int len = sizeof(fasttest::SclCopyNull);
18024 fasttest::SclCopyNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclCopyNull; // default values
18025 ok = SclCopyNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18026 } break; // fasttest::SclCopyNull case
18027
18028 case fasttest_TemplateHeaderMsgsCase_fasttest_SclCopyOpt: {
18029 int len = sizeof(fasttest::SclCopyOpt);
18030 fasttest::SclCopyOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclCopyOpt; // default values
18031 ok = SclCopyOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18032 } break; // fasttest::SclCopyOpt case
18033
18034 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDelta: {
18035 int len = sizeof(fasttest::SclDelta);
18036 fasttest::SclDelta *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDelta; // default values
18037 ok = SclDelta_ReadStrptrMaybe(*ctype, str); // now read attributes
18038 } break; // fasttest::SclDelta case
18039
18040 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaImpl: {
18041 int len = sizeof(fasttest::SclDeltaImpl);
18042 fasttest::SclDeltaImpl *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDeltaImpl; // default values
18043 ok = SclDeltaImpl_ReadStrptrMaybe(*ctype, str); // now read attributes
18044 } break; // fasttest::SclDeltaImpl case
18045
18046 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaNull: {
18047 int len = sizeof(fasttest::SclDeltaNull);
18048 fasttest::SclDeltaNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDeltaNull; // default values
18049 ok = SclDeltaNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18050 } break; // fasttest::SclDeltaNull case
18051
18052 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDeltaOpt: {
18053 int len = sizeof(fasttest::SclDeltaOpt);
18054 fasttest::SclDeltaOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDeltaOpt; // default values
18055 ok = SclDeltaOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18056 } break; // fasttest::SclDeltaOpt case
18057
18058 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDflt: {
18059 int len = sizeof(fasttest::SclDflt);
18060 fasttest::SclDflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDflt; // default values
18061 ok = SclDflt_ReadStrptrMaybe(*ctype, str); // now read attributes
18062 } break; // fasttest::SclDflt case
18063
18064 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltNull: {
18065 int len = sizeof(fasttest::SclDfltNull);
18066 fasttest::SclDfltNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDfltNull; // default values
18067 ok = SclDfltNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18068 } break; // fasttest::SclDfltNull case
18069
18070 case fasttest_TemplateHeaderMsgsCase_fasttest_SclDfltOpt: {
18071 int len = sizeof(fasttest::SclDfltOpt);
18072 fasttest::SclDfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclDfltOpt; // default values
18073 ok = SclDfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18074 } break; // fasttest::SclDfltOpt case
18075
18076 case fasttest_TemplateHeaderMsgsCase_fasttest_SclNone: {
18077 int len = sizeof(fasttest::SclNone);
18078 fasttest::SclNone *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclNone; // default values
18079 ok = SclNone_ReadStrptrMaybe(*ctype, str); // now read attributes
18080 } break; // fasttest::SclNone case
18081
18082 case fasttest_TemplateHeaderMsgsCase_fasttest_SclNoneOpt: {
18083 int len = sizeof(fasttest::SclNoneOpt);
18084 fasttest::SclNoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SclNoneOpt; // default values
18085 ok = SclNoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18086 } break; // fasttest::SclNoneOpt case
18087
18088 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqOrder: {
18089 int len = sizeof(fasttest::SeqOrder);
18090 fasttest::SeqOrder *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqOrder; // default values
18091 algo::ByteAry varlenbuf;
18092 algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18093 algo_lib::_db.varlenbuf = &varlenbuf;
18094 ok = SeqOrder_ReadStrptrMaybe(*ctype, str); // now read attributes
18095 len += ary_N(varlenbuf);
18096 ctype->length = u32(len);
18097 ary_Addary(buf, ary_Getary(varlenbuf));
18098 algo_lib::_db.varlenbuf = varlenbuf_save;
18099 } break; // fasttest::SeqOrder case
18100
18101 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqSgmOpt: {
18102 int len = sizeof(fasttest::SeqSgmOpt);
18103 fasttest::SeqSgmOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqSgmOpt; // default values
18104 algo::ByteAry varlenbuf;
18105 algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18106 algo_lib::_db.varlenbuf = &varlenbuf;
18107 ok = SeqSgmOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18108 len += ary_N(varlenbuf);
18109 ctype->length = u32(len);
18110 ary_Addary(buf, ary_Getary(varlenbuf));
18111 algo_lib::_db.varlenbuf = varlenbuf_save;
18112 } break; // fasttest::SeqSgmOpt case
18113
18114 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrv: {
18115 int len = sizeof(fasttest::SeqTrv);
18116 fasttest::SeqTrv *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrv; // default values
18117 algo::ByteAry varlenbuf;
18118 algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18119 algo_lib::_db.varlenbuf = &varlenbuf;
18120 ok = SeqTrv_ReadStrptrMaybe(*ctype, str); // now read attributes
18121 len += ary_N(varlenbuf);
18122 ctype->length = u32(len);
18123 ary_Addary(buf, ary_Getary(varlenbuf));
18124 algo_lib::_db.varlenbuf = varlenbuf_save;
18125 } break; // fasttest::SeqTrv case
18126
18127 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConst: {
18128 int len = sizeof(fasttest::SeqTrvLenConst);
18129 fasttest::SeqTrvLenConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenConst; // default values
18130 ok = SeqTrvLenConst_ReadStrptrMaybe(*ctype, str); // now read attributes
18131 } break; // fasttest::SeqTrvLenConst case
18132
18133 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenConstOpt: {
18134 int len = sizeof(fasttest::SeqTrvLenConstOpt);
18135 fasttest::SeqTrvLenConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenConstOpt; // default values
18136 ok = SeqTrvLenConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18137 } break; // fasttest::SeqTrvLenConstOpt case
18138
18139 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDflt: {
18140 int len = sizeof(fasttest::SeqTrvLenDflt);
18141 fasttest::SeqTrvLenDflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenDflt; // default values
18142 algo::ByteAry varlenbuf;
18143 algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18144 algo_lib::_db.varlenbuf = &varlenbuf;
18145 ok = SeqTrvLenDflt_ReadStrptrMaybe(*ctype, str); // now read attributes
18146 len += ary_N(varlenbuf);
18147 ctype->length = u32(len);
18148 ary_Addary(buf, ary_Getary(varlenbuf));
18149 algo_lib::_db.varlenbuf = varlenbuf_save;
18150 } break; // fasttest::SeqTrvLenDflt case
18151
18152 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenDfltOpt: {
18153 int len = sizeof(fasttest::SeqTrvLenDfltOpt);
18154 fasttest::SeqTrvLenDfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenDfltOpt; // default values
18155 algo::ByteAry varlenbuf;
18156 algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18157 algo_lib::_db.varlenbuf = &varlenbuf;
18158 ok = SeqTrvLenDfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18159 len += ary_N(varlenbuf);
18160 ctype->length = u32(len);
18161 ary_Addary(buf, ary_Getary(varlenbuf));
18162 algo_lib::_db.varlenbuf = varlenbuf_save;
18163 } break; // fasttest::SeqTrvLenDfltOpt case
18164
18165 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNone: {
18166 int len = sizeof(fasttest::SeqTrvLenNone);
18167 fasttest::SeqTrvLenNone *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenNone; // default values
18168 algo::ByteAry varlenbuf;
18169 algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18170 algo_lib::_db.varlenbuf = &varlenbuf;
18171 ok = SeqTrvLenNone_ReadStrptrMaybe(*ctype, str); // now read attributes
18172 len += ary_N(varlenbuf);
18173 ctype->length = u32(len);
18174 ary_Addary(buf, ary_Getary(varlenbuf));
18175 algo_lib::_db.varlenbuf = varlenbuf_save;
18176 } break; // fasttest::SeqTrvLenNone case
18177
18178 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvLenNoneOpt: {
18179 int len = sizeof(fasttest::SeqTrvLenNoneOpt);
18180 fasttest::SeqTrvLenNoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvLenNoneOpt; // default values
18181 algo::ByteAry varlenbuf;
18182 algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18183 algo_lib::_db.varlenbuf = &varlenbuf;
18184 ok = SeqTrvLenNoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18185 len += ary_N(varlenbuf);
18186 ctype->length = u32(len);
18187 ary_Addary(buf, ary_Getary(varlenbuf));
18188 algo_lib::_db.varlenbuf = varlenbuf_save;
18189 } break; // fasttest::SeqTrvLenNoneOpt case
18190
18191 case fasttest_TemplateHeaderMsgsCase_fasttest_SeqTrvOpt: {
18192 int len = sizeof(fasttest::SeqTrvOpt);
18193 fasttest::SeqTrvOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::SeqTrvOpt; // default values
18194 algo::ByteAry varlenbuf;
18195 algo::ByteAry *varlenbuf_save = algo_lib::_db.varlenbuf;
18196 algo_lib::_db.varlenbuf = &varlenbuf;
18197 ok = SeqTrvOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18198 len += ary_N(varlenbuf);
18199 ctype->length = u32(len);
18200 ary_Addary(buf, ary_Getary(varlenbuf));
18201 algo_lib::_db.varlenbuf = varlenbuf_save;
18202 } break; // fasttest::SeqTrvOpt case
18203
18204 case fasttest_TemplateHeaderMsgsCase_fasttest_StrConst: {
18205 int len = sizeof(fasttest::StrConst);
18206 fasttest::StrConst *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrConst; // default values
18207 ok = StrConst_ReadStrptrMaybe(*ctype, str); // now read attributes
18208 } break; // fasttest::StrConst case
18209
18210 case fasttest_TemplateHeaderMsgsCase_fasttest_StrConstOpt: {
18211 int len = sizeof(fasttest::StrConstOpt);
18212 fasttest::StrConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrConstOpt; // default values
18213 ok = StrConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18214 } break; // fasttest::StrConstOpt case
18215
18216 case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopy: {
18217 int len = sizeof(fasttest::StrCopy);
18218 fasttest::StrCopy *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrCopy; // default values
18219 ok = StrCopy_ReadStrptrMaybe(*ctype, str); // now read attributes
18220 } break; // fasttest::StrCopy case
18221
18222 case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyNull: {
18223 int len = sizeof(fasttest::StrCopyNull);
18224 fasttest::StrCopyNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrCopyNull; // default values
18225 ok = StrCopyNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18226 } break; // fasttest::StrCopyNull case
18227
18228 case fasttest_TemplateHeaderMsgsCase_fasttest_StrCopyOpt: {
18229 int len = sizeof(fasttest::StrCopyOpt);
18230 fasttest::StrCopyOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrCopyOpt; // default values
18231 ok = StrCopyOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18232 } break; // fasttest::StrCopyOpt case
18233
18234 case fasttest_TemplateHeaderMsgsCase_fasttest_StrDflt: {
18235 int len = sizeof(fasttest::StrDflt);
18236 fasttest::StrDflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrDflt; // default values
18237 ok = StrDflt_ReadStrptrMaybe(*ctype, str); // now read attributes
18238 } break; // fasttest::StrDflt case
18239
18240 case fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltNull: {
18241 int len = sizeof(fasttest::StrDfltNull);
18242 fasttest::StrDfltNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrDfltNull; // default values
18243 ok = StrDfltNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18244 } break; // fasttest::StrDfltNull case
18245
18246 case fasttest_TemplateHeaderMsgsCase_fasttest_StrDfltOpt: {
18247 int len = sizeof(fasttest::StrDfltOpt);
18248 fasttest::StrDfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrDfltOpt; // default values
18249 ok = StrDfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18250 } break; // fasttest::StrDfltOpt case
18251
18252 case fasttest_TemplateHeaderMsgsCase_fasttest_StrNone: {
18253 int len = sizeof(fasttest::StrNone);
18254 fasttest::StrNone *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrNone; // default values
18255 ok = StrNone_ReadStrptrMaybe(*ctype, str); // now read attributes
18256 } break; // fasttest::StrNone case
18257
18258 case fasttest_TemplateHeaderMsgsCase_fasttest_StrNoneOpt: {
18259 int len = sizeof(fasttest::StrNoneOpt);
18260 fasttest::StrNoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::StrNoneOpt; // default values
18261 ok = StrNoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18262 } break; // fasttest::StrNoneOpt case
18263
18264 case fasttest_TemplateHeaderMsgsCase_fasttest_U32Const: {
18265 int len = sizeof(fasttest::U32Const);
18266 fasttest::U32Const *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32Const; // default values
18267 ok = U32Const_ReadStrptrMaybe(*ctype, str); // now read attributes
18268 } break; // fasttest::U32Const case
18269
18270 case fasttest_TemplateHeaderMsgsCase_fasttest_U32ConstOpt: {
18271 int len = sizeof(fasttest::U32ConstOpt);
18272 fasttest::U32ConstOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32ConstOpt; // default values
18273 ok = U32ConstOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18274 } break; // fasttest::U32ConstOpt case
18275
18276 case fasttest_TemplateHeaderMsgsCase_fasttest_U32Copy: {
18277 int len = sizeof(fasttest::U32Copy);
18278 fasttest::U32Copy *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32Copy; // default values
18279 ok = U32Copy_ReadStrptrMaybe(*ctype, str); // now read attributes
18280 } break; // fasttest::U32Copy case
18281
18282 case fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyNull: {
18283 int len = sizeof(fasttest::U32CopyNull);
18284 fasttest::U32CopyNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32CopyNull; // default values
18285 ok = U32CopyNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18286 } break; // fasttest::U32CopyNull case
18287
18288 case fasttest_TemplateHeaderMsgsCase_fasttest_U32CopyOpt: {
18289 int len = sizeof(fasttest::U32CopyOpt);
18290 fasttest::U32CopyOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32CopyOpt; // default values
18291 ok = U32CopyOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18292 } break; // fasttest::U32CopyOpt case
18293
18294 case fasttest_TemplateHeaderMsgsCase_fasttest_U32Delta: {
18295 int len = sizeof(fasttest::U32Delta);
18296 fasttest::U32Delta *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32Delta; // default values
18297 ok = U32Delta_ReadStrptrMaybe(*ctype, str); // now read attributes
18298 } break; // fasttest::U32Delta case
18299
18300 case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaImpl: {
18301 int len = sizeof(fasttest::U32DeltaImpl);
18302 fasttest::U32DeltaImpl *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32DeltaImpl; // default values
18303 ok = U32DeltaImpl_ReadStrptrMaybe(*ctype, str); // now read attributes
18304 } break; // fasttest::U32DeltaImpl case
18305
18306 case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaNull: {
18307 int len = sizeof(fasttest::U32DeltaNull);
18308 fasttest::U32DeltaNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32DeltaNull; // default values
18309 ok = U32DeltaNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18310 } break; // fasttest::U32DeltaNull case
18311
18312 case fasttest_TemplateHeaderMsgsCase_fasttest_U32DeltaOpt: {
18313 int len = sizeof(fasttest::U32DeltaOpt);
18314 fasttest::U32DeltaOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32DeltaOpt; // default values
18315 ok = U32DeltaOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18316 } break; // fasttest::U32DeltaOpt case
18317
18318 case fasttest_TemplateHeaderMsgsCase_fasttest_U32Dflt: {
18319 int len = sizeof(fasttest::U32Dflt);
18320 fasttest::U32Dflt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32Dflt; // default values
18321 ok = U32Dflt_ReadStrptrMaybe(*ctype, str); // now read attributes
18322 } break; // fasttest::U32Dflt case
18323
18324 case fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltNull: {
18325 int len = sizeof(fasttest::U32DfltNull);
18326 fasttest::U32DfltNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32DfltNull; // default values
18327 ok = U32DfltNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18328 } break; // fasttest::U32DfltNull case
18329
18330 case fasttest_TemplateHeaderMsgsCase_fasttest_U32DfltOpt: {
18331 int len = sizeof(fasttest::U32DfltOpt);
18332 fasttest::U32DfltOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32DfltOpt; // default values
18333 ok = U32DfltOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18334 } break; // fasttest::U32DfltOpt case
18335
18336 case fasttest_TemplateHeaderMsgsCase_fasttest_U32Incr: {
18337 int len = sizeof(fasttest::U32Incr);
18338 fasttest::U32Incr *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32Incr; // default values
18339 ok = U32Incr_ReadStrptrMaybe(*ctype, str); // now read attributes
18340 } break; // fasttest::U32Incr case
18341
18342 case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNV: {
18343 int len = sizeof(fasttest::U32IncrNV);
18344 fasttest::U32IncrNV *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32IncrNV; // default values
18345 ok = U32IncrNV_ReadStrptrMaybe(*ctype, str); // now read attributes
18346 } break; // fasttest::U32IncrNV case
18347
18348 case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrNull: {
18349 int len = sizeof(fasttest::U32IncrNull);
18350 fasttest::U32IncrNull *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32IncrNull; // default values
18351 ok = U32IncrNull_ReadStrptrMaybe(*ctype, str); // now read attributes
18352 } break; // fasttest::U32IncrNull case
18353
18354 case fasttest_TemplateHeaderMsgsCase_fasttest_U32IncrOpt: {
18355 int len = sizeof(fasttest::U32IncrOpt);
18356 fasttest::U32IncrOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32IncrOpt; // default values
18357 ok = U32IncrOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18358 } break; // fasttest::U32IncrOpt case
18359
18360 case fasttest_TemplateHeaderMsgsCase_fasttest_U32None: {
18361 int len = sizeof(fasttest::U32None);
18362 fasttest::U32None *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32None; // default values
18363 ok = U32None_ReadStrptrMaybe(*ctype, str); // now read attributes
18364 } break; // fasttest::U32None case
18365
18366 case fasttest_TemplateHeaderMsgsCase_fasttest_U32NoneOpt: {
18367 int len = sizeof(fasttest::U32NoneOpt);
18368 fasttest::U32NoneOpt *ctype = new(ary_AllocN(buf, len).elems) fasttest::U32NoneOpt; // default values
18369 ok = U32NoneOpt_ReadStrptrMaybe(*ctype, str); // now read attributes
18370 } break; // fasttest::U32NoneOpt case
18371
18372 default: break;
18373 }
18374 return ok ? msgtype : fasttest::TemplateHeaderMsgsCase();
18375}
18376
18377// --- fasttest.TemplateHeaderMsgs..ReadStrptrMaybe
18378// Parse ascii representation of message into binary, appending new data to BUF.
18379bool fasttest::TemplateHeaderMsgs_ReadStrptrMaybe(algo::strptr str, algo::ByteAry &buf) {
18380 fasttest::TemplateHeaderMsgsCase msgtype = TemplateHeaderMsgs_ReadStrptr(str,buf);
18381 return !(msgtype == fasttest::TemplateHeaderMsgsCase());
18382}